public void disconnect(boolean hard) throws IOException {
synchronized (setupDiscoLock) {
synchronized (this) {
switch (state) {
case 0: /* not connected - just return */
return;
case 2:
hard = true;
case 3: /* connected - go ahead and disconnect */
if (response_map.size() != 0 && !hard) {
break; /* outstanding requests */
}
doDisconnect(hard);
case 4: /* in error - reset the transport */
thread = null;
state = 0;
break;
default:
if (log.level >= 1) log.println("Invalid state: " + state);
thread = null;
state = 0;
break;
}
}
}
}
void bundleAndSend() {
Map.Entry entry;
IpAddress dest;
ObjectOutputStream out;
InetAddress addr;
int port;
byte[] data;
List l;
if (Trace.trace) {
Trace.info(
"UDP.BundlingOutgoingPacketHandler.bundleAndSend()",
"\nsending msgs:\n" + dumpMessages(msgs));
}
synchronized (msgs) {
stopTimer();
if (msgs.size() == 0) {
return;
}
for (Iterator it = msgs.entrySet().iterator(); it.hasNext(); ) {
entry = (Map.Entry) it.next();
dest = (IpAddress) entry.getKey();
addr = dest.getIpAddress();
port = dest.getPort();
l = (List) entry.getValue();
try {
out_stream.reset();
// BufferedOutputStream bos=new BufferedOutputStream(out_stream);
out_stream.write(Version.version_id, 0, Version.version_id.length); // write the version
// bos.write(Version.version_id, 0, Version.version_id.length); // write the version
out = new ObjectOutputStream(out_stream);
// out=new ObjectOutputStream(bos);
l.writeExternal(out);
out.close(); // needed if out buffers its output to out_stream
data = out_stream.toByteArray();
doSend(data, addr, port);
} catch (IOException e) {
Trace.error(
"UDP.BundlingOutgoingPacketHandle.bundleAndSend()",
"exception sending msg (to dest=" + dest + "): " + e);
}
}
msgs.clear();
}
}
public void draw() {
if (_pointLists.size() <= 0) return;
pushStyle();
noFill();
PVector vec;
PVector firstVec;
PVector screenPos = new PVector();
int colorIndex = 0;
// draw the hand lists
Iterator<Map.Entry> itrList = _pointLists.entrySet().iterator();
while (itrList.hasNext()) {
strokeWeight(2);
stroke(_colorList[colorIndex % (_colorList.length - 1)]);
ArrayList curList = (ArrayList) itrList.next().getValue();
// draw line
firstVec = null;
Iterator<PVector> itr = curList.iterator();
beginShape();
while (itr.hasNext()) {
vec = itr.next();
if (firstVec == null) firstVec = vec;
// calc the screen pos
context.convertRealWorldToProjective(vec, screenPos);
vertex(screenPos.x, screenPos.y);
}
endShape();
// draw current pos of the hand
if (firstVec != null) {
strokeWeight(8);
context.convertRealWorldToProjective(firstVec, screenPos);
point(screenPos.x, screenPos.y);
}
colorIndex++;
}
popStyle();
}
/**
* Get the number of subfilters
*
* @return int
*/
public int getServiceMonitorFilterCount() {
return serviceMonitorFilters.size();
}
public int getConnectionCount() {
return Connections.size() + Acceptors.size();
}
public static void main(String[] args) throws IOException {
System.out.println("AuctionClient starting");
Socket auctSocket = null;
PrintWriter out = null;
BufferedReader in = null;
String hostName = "192.168.40.1"; // IP of host (may be local IP)
int socketNum = 7; // the luckiest socket
SeqSSMDPAgent agent = null;
Valuation valuationMethod = null;
String agent_name = "Anonymous";
List<SBAuction> auctions = null;
List<Agent> agents = null;
int agent_id = 0;
int auction_index_number = 0;
// Try reading in the IP and socket number from the text file...
try {
in = new BufferedReader(new FileReader("./src/IP_and_Port.txt"));
// two lines in this file. First is hostName/IP address, and second
// is socket number of host
hostName = in.readLine();
socketNum = Integer.valueOf(in.readLine());
in.close();
} catch (IOException e) {
}
// These are values the agent should remember and use
// Values are initialized when Server sends parameters
int numSlotsNeeded = -1;
int deadline = -1;
double[] valuations = null;
try {
auctSocket = new Socket(hostName, socketNum);
out = new PrintWriter(auctSocket.getOutputStream(), true);
in = new BufferedReader(new InputStreamReader(auctSocket.getInputStream()));
} catch (UnknownHostException e) {
System.err.println("Don't know about host: " + hostName + ".");
System.exit(1);
} catch (IOException e) {
System.err.println("Couldn't get I/O for the connection to: host.");
System.exit(1);
}
System.out.println("Connection to host established");
BufferedReader stdIn = new BufferedReader(new InputStreamReader(System.in));
String fromServer;
// continue to prompt commands from host and respond
while ((fromServer = in.readLine()) != null) {
System.out.println("\n\nServer: " + fromServer);
// Send host this client's unique ID
if (fromServer.equalsIgnoreCase("Send client name")) {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
System.out.println("Enter a unique ID string...");
agent_name = "WJJSIM" + (int) (Math.random() * 100); // br.readLine();
out.println(agent_name); // prompt user for an ID string
System.out.println(agent_name);
// OPTIONAL CHANGE:
// YOU MAY CHOOSE TO REPLACE THE LINE ABOVE WITH THE LINE BELOW
// out.println("My_Hardcoded_Name");
System.out.println("User ID sent. If prompted again, choose another ID/Name string.");
System.out.println("Waiting for server to start auction...");
}
// ***********************************************************************
else if (fromServer.startsWith("agent-parameters:")) {
String[] params = fromServer.split("[ ]"); // tokens delimited
// with spaces
numSlotsNeeded = Integer.valueOf(params[1]); // 1st param is
// number of slots
// needed
deadline = Integer.valueOf(params[2]); // 2nd param is deadline
// DEADLINE IS INDEX OF LAST AUCTION OF VALUE (0-indexed).
// example: deadline = 1 --> first two time-slots can be used
valuations = new double[params.length - 3]; // first 3 stings
// aren't valuations
for (int i = 3; i < params.length; i++) valuations[i - 3] = Double.valueOf(params[i]);
// /////////////////////////////////////////////
// YOUR CODE HERE
// You probably want to store the parameters sent from host.
// For example, you could store them in global variables,
// or use them to initialize an agent class you wrote.
// /////////////////////////////////////////////
valuationMethod = new SchedulingValuation(numSlotsNeeded, valuations);
agents = new ArrayList<Agent>();
auctions = new ArrayList<SBAuction>(valuations.length);
// Let's feed everyone the same input price prediction
ArrayList<Double> weight = new ArrayList<Double>(); // dummy
// weights
ArrayList<DiscreteDistribution> pp = genPrediction(8, 5, false, weight);
agent = new SeqSSMDPAgent(agent_id, valuationMethod, pp);
agents.add(agent);
// int ask_price=0;
// int ask_epsilon=1;
int nth_price = 2;
double reserve_price = 0;
// int auction_id=0;
for (int auction_id = 0; auction_id < valuations.length; auction_id++) {
SBAuction auction = new SBNPAuction(auction_id, reserve_price, 0, 0, agents, nth_price);
auctions.add(auction);
// agent.postResult(new Result(auctions.get(auction_id),
// false, 0, ask_price, 0, ask_epsilon));
}
// /////////////////////////////////////////////
out.println("Parameters accepted");
}
// ***********************************************************************
else if (fromServer.equalsIgnoreCase("submit-bid")) {
// Here are values you should use... be more clever than random!
// numSlotsNeeded (int)
// deadline (int) index of last timeSlot of value (starts at 0)
// valuations (double[numSlots])
// /////////////////////////////////////////////
// YOUR CODE HERE
// Create a string, like myBids, with your bid(s).
// If placing multiple bids, separate bids with spaces spaces.
// If multiple bids, order bids as follows:
// myBids = "timeSlot1Bid timeSlot2Bid ... timeslot5Bid";
//
// Note: bids get rounded to 2 decimal places by host. 5.031 ->
// 5.03
// /////////////////////////////////////////////
// EDIT HERE!
/*
* Random r = new Random();//make random bids...String myBid =
* ""+ (r.nextDouble()*10);
*/
HashMap<Integer, Double> a_bids = agent.getBids();
String myBids = "";
if (a_bids.size() == 1) {
// this is one item, as expected
for (int r : a_bids.keySet()) myBids = "" + a_bids.get(r);
} else if (a_bids.size() == 0) {
// there are no items, bid 0.
myBids = "0.0";
} else {
System.out.println("ERROR: agent submitted wrong number of bids: " + a_bids.size());
System.exit(-1);
}
// /////////////////////////////////////////////
out.println("" + myBids); // Send agent's bids to server (as a
// string)
System.out.println("My bid: " + myBids);
}
// ***********************************************************************
// Observe the state of auction variables. Store information locally
else if (fromServer.startsWith("observe-auction-state:")) {
auction_index_number++;
System.out.println("The auction command has come " + auction_index_number);
String[] stateVars = fromServer.split("[ ]"); // tokens delimited
// with spaces
int numAgents = Integer.valueOf(stateVars[1]);
int numTimeSlots = Integer.valueOf(stateVars[2]);
int currentRound = Integer.valueOf(stateVars[3]); // 1st round ->
// 0
// currentRound is 0-indexed, so currentRound = 0 for first
// round
String[] winnerIDs = new String[currentRound]; //
double[] prices = new double[currentRound];
double[] winBids = new double[currentRound];
for (int i = 0; i < (currentRound * 3); i += 3) { // 3 records
// per
// round:
// winnerID,
// pricePaid,
// bid
winnerIDs[i / 3] = stateVars[4 + i];
prices[i / 3] = Double.valueOf(stateVars[5 + i]);
winBids[i / 3] = Double.valueOf(stateVars[6 + i]);
}
agent.closeAllOpenAuctions();
agent.openAuction(currentRound);
System.out.println(
"+++++++++++Opening current round: " + currentRound + "++++++++++++++++++++\n");
System.out.println(
"Observing state:\nCurrent round = "
+ currentRound
+ "\nNumber of agents = "
+ numAgents
+ "\nNumber of time slots = "
+ numTimeSlots);
System.out.println("Previous round results:");
for (int i = 0; i < winnerIDs.length; i++)
System.out.println(
"Round "
+ i
+ ": winner: "
+ winnerIDs[i]
+ ", price paid = "
+ prices[i]
+ ", with bid = "
+ winBids[i]);
// /////////////////////////////////////////////
// YOUR CODE HERE
// You may want to record some of the state
// information here, especially the results
// from previous auction rounds in winnerIDs
// and prices. The for round i (0-indexed),
// winnerIDs[i] is a unique string ID for the
// agent who won the time-slot and paid prices[i].
// /////////////////////////////////////////////
// EDIT HERE
if (currentRound > 0) {
boolean is_winner = false;
if (winnerIDs[currentRound - 1].equals(agent_name)) {
is_winner = true;
}
int ask_epsilon = 1;
double cur_price = prices[currentRound - 1];
double ask_price = cur_price + ask_epsilon;
double payment = 0;
if (is_winner) payment = cur_price; // payment =
// prices[currentRound-1];
else payment = 0;
agent.postResult(
new Result(
auctions.get(currentRound - 1),
is_winner,
payment,
ask_price,
cur_price,
ask_epsilon));
System.out.println(agent.information());
}
// /////////////////////////////////////////////
out.println("State Observed"); // let the server know client
// received state info
}
// ***********************************************************************
else if (fromServer.startsWith("observe-final-outcome:")) {
String[] outcomeVars = fromServer.split("[ ]"); // tokens
// delimited
// with spaces
// for each slot, announce winner's ID, price paid, and their
// bid
if (outcomeVars.length - 1 < valuations.length * 3) {
out.println("incomplete state"); // let server know state was
// incomplete
} else {
for (int i = 1; i < outcomeVars.length; i += 3) {
// for ith time-slot, winner and price
String winnerID = outcomeVars[i];
double winPrice = Double.valueOf(outcomeVars[i + 1]);
double winBid = Double.valueOf(outcomeVars[i + 2]);
System.out.println(
"Time Slot "
+ (1 + (i / 3))
+ " awarded to ["
+ winnerID
+ "] for price = "
+ winPrice
+ " with bid = "
+ winBid);
}
out.println("Final Outcome Observed"); // let the server know
// client received
// state info
}
}
// ***********************************************************************
// The server says to end the connection
else if (fromServer.equals("END")) {
System.out.println("END called. closing");
break;
}
// ***********************************************************************
else System.out.println("Unexpected input: " + fromServer);
}
out.close();
in.close();
stdIn.close();
auctSocket.close();
}