def test_success(self):
prepare = Prepare(id=3, key='biz', predicate='set', argument='a')
success = Success(prepare=prepare)
self.assertEqual(success.to_json(), {
'status': 'SUCCESS',
'prepare': prepare.to_json()
})
def getNextGameId(self):
"""
Input:
Output: Success[Int] or Failure
"""
maybeMaxGameId = self.database.getMaxGameId()
if (maybeMaxGameId.isFailure()):
return maybeMaxGameId
else:
maxGameId = maybeMaxGameId.get()
if (maxGameId == []):
return Success(1)
else:
return Success(maxGameId + 1)
def writeQuery(self, queryString, parameters):
try:
self.cursor.execute(queryString, parameters)
return Success("Write Query Successful")
except:
print("Error executing write query")
return Failure("Error executing write query")
def removeFriend(self,username,friend):
"""
Input: username: String, friend: String
Output: Success[String] or Failure
"""
isRealPlayers = self.playersExist([username,friend])
if (not isRealPlayers):
return Failure("User does not exist!")
else:
userOneFriends = self.getFriendsForUser(username)
userTwoFriends = self.getFriendsForUser(friend)
if (userOneFriends.isFailure()):
return userOneFriends
if (userTwoFriends.isFailure()):
return userTwoFriendsCsv
else:
userOneFriendsList = csvToList(userOneFriends.getOrElse([]))
userTwoFriendsList = csvToList(userTwoFriends.getOrElse([]))
if (friend not in userOneFriendsList):
return Failure("User is not friends with this other user")
elif (username not in userTwoFriendsList):
return Failure("Friend is not friends with this user")
else:
userOneFriendsList.remove(friend)
userTwoFriendsList.remove(username)
resultOne = self.database.updateFriendList(username,listToCsvString(userOneFriendsList))
resultTwo = self.database.updateFriendList(friend,listToCsvString(userTwoFriendsList))
if (resultOne.isFailure()):
return resultOne
elif (resultTwo.isFailure()):
return resultTwo
else:
return Success("Friend Removed")
def post(self):
learn = Learn.from_request(self.request)
logger.info("Adding new learn, %s, to completed rounds.",
learn.to_json())
completed_rounds.add(learn)
ordered_rounds.append(learn)
success = Success(prepare=learn.prepare)
self.respond(code=200, message=success)
def getQuery(self, queryString, parameters):
try:
self.cursor.execute(queryString, parameters)
except:
print("Error executing get query")
return Failure("Error executing get query")
rows = self.cursor.fetchall()
result = Success(rows)
return result
def test_learner_learns(self):
learn = Learn(prepare=self.get_prepare())
response = self.post('/learn', learn.to_json())
self.assertEqual(response.code, 200)
self.assertEqual(
Success.from_response(response).to_json(), {
'status': 'SUCCESS',
'prepare': self.get_prepare().to_json()
})
self.assertEqual(
agent.completed_rounds.highest_numbered().prepare.to_json(),
self.get_prepare().to_json())
def getGameFromGameId(self,gameId):
"""
Input: gameId: String
Output: Success[Game] or Failure
"""
if (self.database.gameIdExists(gameId).getOrElse([(0,)])[0][0] != 1):
return Failure("Game Id doesn't exist")
else:
gameRowResult = self.database.getByGameId(gameId)
if (gameRowResult.isFailure()):
return Failure("Failed to get game from the database")
else:
gameData = gameRowResult.get()[0][0]
decodedGame = self.jsonDecoder.decode(gameData)
return Success(decodedGame)
def acceptFriendRequest(self,username,otherUsername):
"""
Input: username: String, otherUsername: String
Output: Success[String] or Failure
"""
isRealPlayers = self.playersExist([username,otherUsername])
if (isRealPlayers):
return Failure("User does not exist!")
else:
userOneRequests = self.getFriendRequestsForUser(username)
userOneFriends = self.getFriendsForUser(username)
userTwoFriends = self.getFriendsForUser(otherUsername)
if (userOneRequests.isFailure()):
return userOneRequests
elif (userOneFriends.isFailure()):
return userOneFriends
elif (userTwoFriends.isFailure()):
return userTwoFriends
else:
newUserOneRequests = userOneRequests.getOrElse([])
newUserOneFriends = userOneFriends.getOrElse([])
newUserTwoFriends = userTwoFriends.getOrElse([])
if (otherUsername not in newUserOneRequests):
return Failure("Other user is not in users requests")
elif (otherUsername in newUserOneFriends or username in newUserTwoFriends):
return Failure("Users are already friends")
else:
newUserOneRequests.remove(otherUsername)
newUserOneFriends.append(otherUsername)
newUserTwoFriends.append(username)
resultOne = self.database.updateFriendRequestList(username,listToCsvString(newUserOneRequests))
resultTwo = self.database.updateFriendList(username,listToCsvString(newUserOneFriends))
resultThree = self.database.updateFriendList(otherUsername,listToCsvString(newUserTwoFriends))
if (resultOne.isFailure()):
return resultOne
elif (resultTwo.isFailure()):
return resultTwo
elif (resultThree.isFailure()):
return resultThree
else:
return Success("Friend Request Accepted")
def createGame(self,gameName,players):
"""
Input: gameName: String, players: List[String]
Output: Success[Game] or Failure
"""
gameId = self.getNextGameId()
if (not self.playersExist(players)):
return Failure("User does not exist")
elif (gameName == "ChessGame"):
game = ChessGame(str(gameId),players)
playerOneIds = self.database.getGameIdsForUser(players[0]).get()[0][0]
newPlayerOneIds = listToCsvString(playerOneIds.split(",").append(gameId))
playerTwoIds = self.database.getGameIdsForUser(players[1]).get()[0][0]
newPlayerTwoIds = listToCsvString(playerTwoIds.split(",").append(gameId))
updateOne = self.database.updateGameIdsForUser(newPlayerOneIds,players[0])
updateTwo = self.database.updateGameIdsForUser(newPlayerTwoIds,players[1])
if (updateOne.isSuccess() and updateTwo.isSuccess()):
return Success(game)
else:
Failure("Failed to update game ids for a user")
else:
return Failure("Generic Failure")
def changeUsersPassword(self,username,oldPassword,newPassword):
playerExists = self.database.userExists(username)
if (playerExists.getOrElse(0) != 1):
return Failure("User does not exist!")
else:
if (username == "uni"):
return Failure("Cannot update password")
else:
maybePasswordHash = self.database.getUsersPassword(username)
if (maybePasswordHash.isFailure()):
return Failure("Failed to get users old password")
else:
if (encryption_context.verify(oldPassword,maybePasswordHash.getOrElse(""))):
result = self.database.changePassword(username,self.encryptString(newPassword))
if (result.isFailure()):
logResultOne = self.database.enterLogMessage("Update password Query error for user: '******'")
if (logResultOne.isFailure()):
print(logResultOne.getErrorMessage())
return result
else:
logResultTwo = self.database.enterLogMessage("'" + username + "' changed their password")
if (logResultTwo.isFailure()):
print(logResultTwo.getErrorMessage())
return Success("Password Changed Successfully")
def save_result(result):
if result:
session = Session()
new_success = Success(**result)
session.add(new_success)
session.commit()
def post(self):
"""
{
key: <str>,
predicate: <str>,
argument: <str|int>
}
"""
request = json.loads(self.request.body)
prepare = Prepare(**request)
prepares = collections.deque([prepare])
current_promises.add(Promise(prepare=prepare))
quorum = agents.quorum(excluding=options.port)
while prepares: # TODO: Timeout here.
prepare = prepares.popleft()
logging.info("Sending prepare for %s", prepare)
responses, issued, conflicting = yield prepare.send(quorum)
logger.info("Got %s issued and %s conflicting", len(issued),
len(conflicting))
logger.info("Response codes: %s",
", ".join([str(r.code) for r in responses]))
if conflicting: # Issue another promise.
logger.warning(
"%s was pre-empted by a higher ballot. retrying.".format(
prepare.id))
prepares.append(
Prepare(key=prepare.key,
predicate=prepare.predicate,
argument=prepare.argument))
continue
elif len(issued) != len(quorum):
raise tornado.web.HTTPError(
status_code=500,
log_message='FAILED to acquire quorum on Promise')
promises = Promises.from_responses(responses)
earlier_promise = promises.highest_numbered()
if earlier_promise and earlier_promise not in current_promises: # Repair.
prepares.append(prepare)
prepare = earlier_promise.prepare
# Now we have a promise.
responses, issued, conflicting = yield Propose(
prepare=prepare).send(quorum)
if len(issued) == len(quorum):
logger.info("Got success for propose %s. Learning...", prepare)
successes = yield Learn(prepare).fanout(expected=Success)
elif conflicting:
logger.error("Conflicting promise detected. Will re-issue.")
raise Exception("Conflicting promise detected.")
else:
raise tornado.web.HTTPError(
status_code=500,
log_message='Failed to acquire quorum on Accept')
if len(successes) == len(agents.all()):
current_promises.remove(prepare)
self.respond(Success(prepare))
else:
logger.error("Got %s successes with a required quorum of %s",
len(successes), len(agents.all()))
raise tornado.web.HTTPError(
status_code=500,
log_message='Failed to acquire quorum on Learn')