Java Client-Server with Sockets

CO2017 — Exercise 3 — Java Client-Server with Sockets

Preamble

Some of these questions will be must be handed in for assessment by the end of April 30th. Detailed submission instructions will be added in due course.

Please check back here for last minute updates before submitting your work

There is now a module forum. You need your usual UoL username password to connect; you can post anonymously, or login within the forum using your informatics linux username/password. All posts are moderated, so might not show up immediately.

You should review Lecture 15 for discussion of Socket programming in java and basic client/server architecture.

The deadline for this work is Monday 30th April.

In this page (and in other pages for this module):

Pale yellow boxes indicate code or other material that should be the contents of a file — you will generally use an editor, such as Emacs, Scite or GEdit to enter/view the content.

Pale blue boxes indicate a place where you should be entering a command, e.g. at a command prompt in a terminal window.

Pale pink boxes indicate interactive use, with the input you should type in RED; other text is expected output from a program.

Hints and asides are written in pink italics.

Question 1 — Number Square Service (Unassessed)

Your task is to write a pair of programs, client and server, to implement a number squaring service. This initally be similar to the TimeServer/Client example discussed in lectures.

You will need to choose a port to run your service on. To get a unique port number, try using your numeric uid. "getent passwd" will tell you your uid (and your gid).

Client

The client uses a Socket to make a connection to the server. Once connected, the client prompts the user for a number (in the console; no need for a GUI), and sends it to the server. The server responds with the square of the number, which the client will print on the screen.

Keep going until the user submits the special number 999. The client should send the special number, then shut down.

Server

Server listens for connections. When a connection is made, it should create a handler Thread which waits for numbers to be sent from the client. After receiving a number, it should calculate the square and send it back to the client.

Repeat until the client sends the special number 999.

Extra features

What happens if the client tries to connect and no server is running?
What happens if one end just stops in the middle (client never sends another number; server never responds to a request)?
Test it over two machines. Try running more than one client against one server.
Test your client with another person's server; and vice versa.

Unassessed — model solution here

Question 2 — Online Voting (assessed)

The worksheet is presented in several phases to lead you towards a working solution. If you do not make it to the final phase, you should hand in as far as you have managed. If you do make it to the final phase, you only need to hand that in.

The theme of the exercise is to produce a simple client/server on-line voting system. The server will:

be setup with a fixed candidate list (the BallotPaper) and a list of eligible voters (the VoterList);
accept connections from clients (voters); send the voter a copy of the list of candidates and then record their vote.

It is important that you write your code in a java package called "CO2017.exercise3. This will simplify the marking process. To achieve this, you need to start each code file with a line like this (replaceabc123with your own username).

package CO2017.exercise3.abc123;

If you are using eclipse or a similar IDE, it should have tools available to make it simple to write your code in a specific package, and/or to move code from one package to another.

Phase 0

Download the jar file containing the package CO2017.exercise3.support of basic classes for representing Ballots, Ballot boxes and lists of voters. UPDATED (28th March) so it can be imported as library in eclipse. This code forms the package CO2017.exercise3.support.

See javadoc documentation for the classes included. This describes the public interface provided by the classes. You do not need to implement these yourself.

See test code area for some basic test programs. You can use these to explore the behaviour of the provided CO2017.exercise3.support package, and verify that you have installed them properly.

See also junit test code for some basic junit test programs. Provided for completeness only — you do not need to use these. Working out how to compile and run these junit test cases is left as an exercise for the reader…

Phase 1

In this phase, you will produce simple client and server programs to implement a protocol for online voting. The client and server will make use of the basic data structure classes from Phase 0.

Note that 70% of the CW3 assessment marks are for phase 1.

Protocol

This section describes the protocol that the client and server use to communicate. Note that the messages passed between client and server using the protocol are not necessarily the same as the messages that will be displayed on-screen for the user of the system.

In all cases

vid, bnum are decimal integers (in String form) representing unique voter and ballot identifiers;
vote is a single character vote;
BALLOT, OK, END, etc are literal Strings values;
similarly, Xvid, Xbnum, Xvote and XXXX are values that do not match the expected ones (used in the transaction so far);
values on a single line are separated with colons (':');
lines are to be terminated where shown;
data should be flushed after each message;
{close connection} indicates that the socket connection should be closed

Here are some typical protocol transactions between an individual client and the server.

A typical (no error) vote transaction:

CLIENT		SERVER	Comment
`vid`	`=>`		client requests a ballot
	`<=`	vid:bnum:BALLOT A:Candidate 1 B:Candidate 2 0:END	server sends back the `vid`, a new & unique ballot id (`bnum` and the string "`BALLOT`"; and then, starting on a new line, the ballot paper, one candidate per line, terminated with "0:END" on a line of its own.
`vid:bnum:vote`	`=>`		client sends back the vid, the ballot id, plus the vote
	`<=`	vid:bnum:vote:OK {close connection}	server sends back the vid, a ballot id, the received vote, plus "OK"; then closes the connection
{close connection}			client closes the connection

Client attempts duplicate vote:

CLIENT		SERVER	Comment
vid	`=>`		client sends a duplicate voter id (who has already voted)
	`<=`	vid:0:DUPLICATE {close connection}	server sends back the `vid`, the special ballot id `0` (zero) and the string "`DUPLICATE`"; and then closes the connection
{close connection}			client displays an error message and closes the connection

Vote closing transaction:
CLIENT SERVER Comment
0 {close connection}
=>

client sends special zero value and closes the connection
{close connection}
server closes connection and closes the ballot
Incorrect initial response from server:

CLIENT		SERVER	Comment
`vid`	`=>`		client requests a ballot
	`<=`	Xvid:Xbnum:XXXX	server sends back a different voter id OR ballot id OR a string other than `BALLOT`
`{close connection}`			client closes the connection (and therefore, so will server) — no vote will be recorded

Incorrect 2nd response from client:

CLIENT		SERVER	Comment
`vid`	`=>`		client requests a ballot
	`<=`	vid:bnum:BALLOT A:Candidate 1 B:Candidate 2 0:END	server sends back the correct vid, a ballot id, plus the ballot paper, terminated with "0:END"
`Xvid:Xbnum:vote`	`=>`		client sends back the something other than the expected voter id OR ballot id OR a vote that is not possible then the vote must be discarded
	`<=`	`vid:bnum:vote:ABORT {close connection}`	server aborts the vote and closes the connection
{close connection}			client displays an error message and closes the connection

Incorrect 2nd response from server:

CLIENT		SERVER	Comment
`vid`	`=>`		client requests a ballot
	`<=`	vid:bnum:BALLOT A:Candidate 1 B:Candidate 2 0:END	server sends back the correct vid, a new & unique ballot id; then, starting on a new line, the ballot paper, terminated with "0:END"
`vid:bnum:vote`	`=>`		client sends back the vid, the ballot id, plus the vote
	`<=`	Xvid:Xbnum:Xvote:XXXX {close connection}	server records the vote, but then (for some reason) sends back an incorrect response (one or more of voter id, ballot number, vote or the "OK" message are wrong) and closes the connection
{close connection}			display a warning to voter about the incorrect response from the server and then close the connection

I/O streams

To avoid confusion, all data should be sent as String values. Do not use Data readers/writers to send numbers. You should use something very like this (on both ends of the connection):

BufferedReader rdr = new
  BufferedReader(new InputStreamReader(server.getInputStream(),                                       "UTF-8"));Writer out = new OutputStreamWriter(server.getOutputStream());

Make sure that strings you write are terminated (with "\r\n" or, if using formatted strings, with "%n").

Make sure you flush the output buffer after finishing each transaction.

You can then use readLine to read in complete lines on the other end of the connection.

Phase 1A: Simple client — `Voter.java`

This is a simple interactive client, for use in a command line terminal. For example, here are several successive invocations of the simple client program:

$ java CO2017.exercise3.gtl1.Voter localhost 8111Connected to localhost/127.0.0.1
Enter voter id: 12341234: 1
A:E.Smith (Apple Affiliates)
B:B.Jones (Android Alliance)
C:A.Brown (Microsoft Party)
D:D.Green (Blackberry Bunch)
E:C.Black (Penguinistas)
Enter vote: EVote processed OK
$ java CO2017.exercise3.gtl1.Voter localhost 8111Connected to localhost/127.0.0.1
Enter voter id: 12351235: 2
A:E.Smith (Apple Affiliates)
B:B.Jones (Android Alliance)
C:A.Brown (Microsoft Party)
D:D.Green (Blackberry Bunch)
E:C.Black (Penguinistas)
Enter vote: DVote processed OK
$ java CO2017.exercise3.gtl1.Voter localhost 8111Connected to localhost/127.0.0.1
Enter voter id: 14321432: 3
A:E.Smith (Apple Affiliates)
B:B.Jones (Android Alliance)
C:A.Brown (Microsoft Party)
D:D.Green (Blackberry Bunch)
E:C.Black (Penguinistas)
Enter vote: EVote processed OK
$ java CO2017.exercise3.gtl1.Voter localhost 8111Connected to localhost/127.0.0.1
Enter voter id: 1432      <!!!! repeat vote !!!!!1432: 0
1432 has already voted; VOTE REJECTED.
$ java CO2017.exercise3.gtl1.Voter localhost 8111Connected to localhost/127.0.0.1
Enter voter id: 0Closing voting on localhost
$

When invoked, the server hostname and port are supplied as command line arguments.

The client then prompts the user for their candidate number. This is sent to the server, which responds with a string representation of the ballot paper, which should be printed out. Assume that valid voter numbers are between 1000 and 1999 (inclusive).

The client then prompts the user for their vote (a single character), which is sent to the server.

The special voter id number of 0 (zero) causes the server to shut down.

Code to submit:

Voter.java (if you complete phase 3, just hand in the phase 3 version along with VoteClientHandler.java)

Assessed: 35% of the assessment

Phase 1B: Simple Server — `PollServer.java`

The server is invoked with a port number to listen on, plus the name of a file containing the candidate list (example file here). It should start up and listen for incoming client requests. Each request should result in a separate handler thread being started to deal with the connection.

Your Poll should have a voter list with voter ids between 1000 and 1999 inclusive.

Example behaviour:

$ java CO2017.exercise3.gtl1.PollServer 8111 candidates.txt Vote client /127.0.0.1:57903 connected.
Voter /127.0.0.1:57903 requests ballot for: 1234
Sent ballot paper number 1 for 1234
Got vote: E
Vote client /127.0.0.1:57907 connected.
Voter /127.0.0.1:57907 requests ballot for: 1235
Sent ballot paper number 2 for 1235
Got vote: D
Vote client /127.0.0.1:57910 connected.
Voter /127.0.0.1:57910 requests ballot for: 1432
Sent ballot paper number 3 for 1432
Got vote: E
Vote client /127.0.0.1:47818 connected.
Voter /127.0.0.1:47818 requests ballot for: 1432        <!!!! repeat vote !!!!!InvalidVoterTransition: 1432 already VOTED
1234 has already voted; VOTE REJECTED
Vote client /127.0.0.1:57913 connected.
Closing Poll
E.Smith (Apple Affiliates): 0
B.Jones (Android Alliance): 0
A.Brown (Microsoft Party): 0
D.Green (Blackberry Bunch): 1
C.Black (Penguinistas): 2
Turnout: 3
Ballot is: closed
WINNER is: E [C.Black (Penguinistas)]
$

Code to submit:

PollServer.java (if you complete phase 2, just hand in the phase 2 version along with VoteHandler.java)

Assessed: 35% of the assessment

Phase 2: Multi-threaded server — `VoteHandler`

Your PollServer from section 1B can only handle a single voter client at a time. In this phase you will extend it to be able to handle multiple concurrent connections.

To do this write a VoteHandler class that implements the Runnable interface. Each instance will deal with a single vote on the server side.

Modify your PollServer class so that for each new client connection, it creates a new VoteHandler instance and starts it in its own thread.

Test your server by starting multiple instances of the client at the same time (perhaps using different hosts). For maximum marks multiple clients should all be able to communicate with the server concurrently.

To control the vote handler threads, you can either control them yourself (by just invoking the start method); or you can setup a ThreadPoolExecutor, as seen in Exercise 2.

You will find one of hardest parts is to close the PollServer when the special voter id 0 is sent. The normal pattern is that a handler is created for each new connection as soon as it is made (which is before you know what the voter id is). This means that the main server loop may be blocked running server.accept(), waiting for a new client connection even though the Ballot is closed (and therefore no more votes will be coming).

To get around this problem, you can set a timeout on the socket (pseudo-code):

do {
  server = new ServerSocket(port);
  server.setSoTimeout(10000); // 10s timeout
  try {
    Socket client = server.accept();
    ... // Do something with the socket if a connection is made
  }
  catch (SocketTimeoutException e) {
    if (stopCondition) break;  // exit the loop if stop condition is met
    // otherwise, continue with the loop
  }} while (true);

Code to submit:

VoteHandler.java

Assessed: 20% of the assessment

Phase 3: Bulk voting

Your simple client (Voter class) has to interact with the end-user twice:

to read in the voter id who is going to vote;
to display the ballot and read in the voter's choice.

In phase 3, you will convert the client to a self-contained vote handler that uses call-backs to get these external bits of information.

`VoteClient` interface

The VoteClient interface, is part of the CO2017.exercise3.support package that you have already downloaded and installed. Actual clients must implement this interface in order to provide the needed callbacks.

`VoteClientHandler` (implements `Runnable`)

Produce a class that can run a single voter client as a thread. You will need to implement these public methods:

VoteClientHandler(Socket s, VoteClient vc)
Constructor. Set up BufferedReader and Writer instances attached to the Socket
void run()
Implement the client functionality as described in phase 1A. Use the getVid() and getVote(BallotPaper bp) callbacks from the VoteClient object to provide the voter id and the voter's actual vote.

Re-implement simple `Voter` class

Re-implement the simple Voter class from phase 1A using your VoteClientHandler class. You will need to make your Voter class implement the VoteClient interface by providing these methods:

int getVid() must prompt the user for their voter id;
char getVote(BallotPaper bp) should display the ballot paper to the user and read in their vote.

The main method of your improved Voter class will simply attempt to connect to the server, and then immediately create and start a VoteClienthandler thread. Since this is a simple client that only needs to handle a single vote, you can then just use join to wait for the handler to finish.

Bulk client: `VoteStuffer`

Use your VoteClientHandler class to implement a bulk voting program. It should read in voter identifiers and votes from from a file.

You will need to make your VoteStuffer class implement the VoteClient interface by providing these methods:

int getVid() must return the next voter id from the file;
char getVote(BallotPaper bp) can ignore the BallotPaper and just return the next vote from the file.

Note that for each voter, the VoteStuffer program will open a new connection to the PollServer.

Initially you can just work through the file of votes sequentially. But for maximum marks you should use a ThreadPoolExecutor to run multiple voters concurrently.

Example of the VoteStuffer in action:

$ java CO2017.exercise3.gtl1.VoteStuffer localhost 8111 votes.txt1029:B
Vote processed OK
1329:B
Vote processed OK
1042:A
Vote processed OK
1042:A
1042 has already voted; VOTE REJECTED
0:X
Closing voting on localhost
$

The input file should contain entries one vote per line: "vid:vote" where vid is a voter number, and vote is that voters single character vote.

Here is a program you can use to generate suitable input files: GenVoteList.java. Note that:

the generated list ends with a vote "0:X" in order to force the closure of the Poll;
the generated test file will not contain any duplicates.

Code to submit:

Voter.java
VoteClientHandler.java
VoteStuffer.java

Assessed: 10% of the assessment

Assessment and submission

Overall: 15% of MODULE mark

Submission

Your complete solution should be in the specified source files. It is acceptable to use additional local classes within the source files specified.

If you do not complete all phases, you should hand in as far as you have managed. For example, if you have working code for phase 2, and partial but non-working code for (say) phase 3, then submit the working code using the handin system, and use the "notes" section to mention the extra work; you can email the non-working code to me directly if you wish.

PLEASE check back here prior to submitting your work in case there are any last minute updates.

Static evaluation

Your work will be assessed on both functionality (with dynamic testing using various input parameters, see below), and statically on matters of layout and coding style, including, but not limited to:

Use of comments, including clear identification of the author.
Appropriate choice of identifier names (variables, etc).
Where class, method and attribute names are specified, you should stick precisely to the specification.
Where output strings are specified, you should conform to the specification. Generally you should not include output that is not explicitly required.
Indentation and spacing.

See the style guidelines for more details.

Dynamic testing

Your code will be tested using a linux environment very similar to that on the linux machines in the CS department labs.
NB: your code should compile successfully with simple invocations of "javac" at the command line.

It is important that your classes provide the specified interfaces exactly as described as each class will be tested in isolation, or against the "reference" implementation (in other words against the model answer).

Phase 1A: Basic client class
Your Voter class will be compiled and tested against the reference implementation of the the PollServer class.
Phase 1B: Basic server class
Your PollServer class will be compiled and tested against a test class that submits multiple votes sequentially.
Phase 2: Multi-thread server class
Your PollServer and VoteHandler classes will be compiled and tested against a reference version of the VoteStuffer class.
Phase 3
Your VoteStuffer class will be compiled and tested against the reference implementation of the PollServer and VoteHandler classes.

代写CS&Finance|建模|代码|系统|报告|考试

编程类：C++,JAVA ,数据库,WEB,Linux,Nodejs,JSP,Html,Prolog,Python,Haskell,hadoop算法,系统机器学习

金融类：统计，计量，风险投资，金融工程，R语言，Python语言，Matlab，建立模型，数据分析，数据处理

服务类：Lab/Assignment/Project/Course/Qzui/Midterm/Final/Exam/Test帮助代写代考辅导

E-mail:850190831@qq.com 微信：BadGeniuscs 工作时间：无休息工作日-早上8点到凌晨3点

如果您用的手机请先保存二维码到手机里面，识别图中二维码。如果用电脑，直接掏出手机果断扫描。

CO2017 — Exercise 3 — Java Client-Server with Sockets

关键字：