← Back to branch summary

~elambert/gearmanij/gearman_java_library

« back to all changes in this revision

Viewing changes to src/gearmanij/client/GearmanServerRequest.java

  • Committer: Eric Lambert
  • Date: 2009-07-06 03:12:19 UTC
  • Revision ID: eric.d.lambert@gmail.com-20090706031219-a51t0d91vd5au8m6
make GearmanServerRequest an event listener and use the event listening mechanism to update status of request

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gearmanij/client/GearmanServerRequest.java
6
6
 */
7
7
package gearmanij.client;
8
8
 
9
 
import java.util.LinkedList;
10
 
import java.util.Queue;
11
9
import java.util.UUID;
12
10
import java.util.logging.Level;
13
11
import java.util.logging.Logger;
14
12
 
15
13
import gearmanij.GearmanException;
 
14
import org.gearman.GearmanJobEventListener;
16
15
import org.gearman.GearmanPacket;
17
16
import org.gearman.PacketMagic;
18
17
 
19
 
class GearmanServerRequest {
 
18
class GearmanServerRequest implements GearmanJobEventListener{
20
19
 
21
20
    enum RequestState {
22
21
        NEW, AWAITINGRESPONSE, PROCESSINGRESPONSES, FINISHED,
27
26
    private final String DESCRIPTION;
28
27
    private RequestState state = null;
29
28
    private GearmanPacket requestPacket = null;
30
 
    private Queue<GearmanPacket> responsePackets = new LinkedList<GearmanPacket>();
31
29
    private UUID uuid = null;
32
30
    private GearmanServerResponseHandler handler = null;
33
31
    private static final Logger LOG = GearmanClientImpl.getLogger();
56
54
 
57
55
    }
58
56
 
59
 
    void addResponsePacket(GearmanPacket p) {
 
57
    public void handleGearmanJobEvent(GearmanPacket p) throws IllegalArgumentException {
60
58
        if (p == null) {
61
59
            throw new IllegalArgumentException("You can not add a null" +
62
60
                    " response packet");
63
61
        }
64
 
        if (!p.getMagic().equals(PacketMagic.RES)) {
65
 
            throw new IllegalArgumentException("Invalid packet magic. Packet" +
66
 
                    " is not a response packet");
67
 
        }
68
 
        responsePackets.add(p);
69
 
    }
70
 
 
71
 
    GearmanPacket getRequestPacket() {
72
 
        return requestPacket;
73
 
    }
74
 
 
75
 
    GearmanServerResponseHandler getHandler() {
76
 
        return handler;
77
 
    }
78
 
 
79
 
    public String toString() {
80
 
        return DESCRIPTION;
81
 
    }
82
 
 
83
 
    RequestState getState() {
84
 
        return state;
85
 
    }
86
 
 
87
 
    void driveRequest() throws GearmanException {
88
 
        GearmanPacket p = null;
89
 
        while (true) {
90
 
            switch (state) {
 
62
        switch (state) {
91
63
 
92
64
                // request needs to be submitted to server
93
65
                case NEW:
94
 
                    if (requestPacket == null) {
95
 
                        changeState(RequestState.EXCEPTION);
96
 
                        break;
97
 
                    }
98
 
                    if (!requestPacket.requiresResponse()) {
99
 
                        state = RequestState.FINISHED;
100
 
                        break;
101
 
                    }
 
66
                    if (p.getMagic().equals(PacketMagic.REQ)) {
 
67
                        if (requestPacket.requiresResponse()) {
 
68
                            changeState(RequestState.AWAITINGRESPONSE);
 
69
                        } else {
 
70
                            changeState(RequestState.FINISHED);
 
71
                        }
 
72
                    } else {
 
73
                        //TODO
 
74
                    }
 
75
                    break;
102
76
 
103
77
                case AWAITINGRESPONSE:
104
 
                    if (responsePackets.isEmpty()) {
105
 
                        changeState(RequestState.AWAITINGRESPONSE);
106
 
                        return;
 
78
                    if (p.getMagic().equals(PacketMagic.RES)) {
 
79
                        changeState(RequestState.PROCESSINGRESPONSES);
 
80
                    } else {
 
81
                        //TODO (for now we break to avoid falling through)
 
82
                        break;
107
83
                    }
108
84
 
109
85
                case PROCESSINGRESPONSES:
110
 
                    if (responsePackets.isEmpty()) {
111
 
                        changeState(RequestState.PROCESSINGRESPONSES);
112
 
                        return;
 
86
                    if (!p.getMagic().equals(PacketMagic.RES)) {
 
87
                        //TODO
 
88
                        break;
113
89
                    }
114
 
                    p = responsePackets.remove();
115
90
                    if (handler == null) {
116
91
                        LOG.log(Level.WARNING,"ServerRequest requires " +
117
92
                                "response, but not response handler was " +
142
117
                    throw new GearmanException("Unknown Request state " +
143
118
                            state + " for request " + requestPacket);
144
119
            }
145
 
        }
 
120
    }
 
121
 
 
122
    GearmanPacket getRequestPacket() {
 
123
        return requestPacket;
 
124
    }
 
125
 
 
126
    GearmanServerResponseHandler getHandler() {
 
127
        return handler;
 
128
    }
 
129
 
 
130
    public String toString() {
 
131
        return DESCRIPTION;
 
132
    }
 
133
 
 
134
    RequestState getState() {
 
135
        return state;
146
136
    }
147
137
 
148
138
    private void changeState(RequestState newState) {