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)

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.

     

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:

  1. be setup with a fixed candidate list (the BallotPaper) and        a list of eligible voters (the VoterList);

  2. 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
    SERVERComment
    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
    SERVERComment
    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
    SERVERComment
    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
    SERVERComment
    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
    SERVERComment
    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
    SERVERComment
    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:

  1. to read in the voter id who is going to vote;

  2. 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点


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

qr.png


美国留学代写

JAVA

2018-04-13


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