Commit 8f08613c authored by Grégory Wisniewski's avatar Grégory Wisniewski

As previous commits, use new Enum class for cell states.


git-svn-id: https://svn.erp5.org/repos/neo/trunk@1339 71dcc9de-d417-0410-9af5-da40c76e7ee4
parent 6d746894
......@@ -868,8 +868,8 @@ class Application(object):
last = first - last
# First get a list of transactions from all storage nodes.
# Each storage node will return TIDs only for UP_TO_DATE_STATE and
# FEEDING_STATE cells
# Each storage node will return TIDs only for UP_TO_DATE state and
# FEEDING state cells
pt = self._getPartitionTable()
storage_node_list = pt.getNodeList()
......
......@@ -18,10 +18,9 @@
from neo import logging
from neo import protocol
from neo.protocol import UP_TO_DATE_STATE, FEEDING_STATE, \
DISCARDED_STATE, OUT_OF_DATE_STATE, INTERNAL_ERROR_CODE
from neo.protocol import INTERNAL_ERROR_CODE
from neo.protocol import UnexpectedPacketError, CellStates
from neo.master.handlers import BaseServiceHandler
from neo.protocol import UnexpectedPacketError
from neo.exception import OperationFailure
from neo.util import dump
......@@ -90,7 +89,7 @@ class StorageServiceHandler(BaseServiceHandler):
new_cell_list = []
for cell in cell_list:
if cell[2] != UP_TO_DATE_STATE:
if cell[2] != CellStates.UP_TO_DATE:
logging.warn('only up-to-date state should be sent')
continue
......@@ -104,7 +103,8 @@ class StorageServiceHandler(BaseServiceHandler):
# check the storage said it is up to date for a partition it was assigne to
for xcell in app.pt.getCellList(offset):
if xcell.getNode().getUUID() == node.getUUID() and \
xcell.getState() not in (OUT_OF_DATE_STATE, UP_TO_DATE_STATE):
xcell.getState() not in (CellStates.OUT_OF_DATE,
CellStates.UP_TO_DATE):
msg = "node %s telling that it is UP TO DATE for offset \
%s but where %s for that offset" % (dump(node.getUUID()), offset,
xcell.getState())
......@@ -113,15 +113,15 @@ class StorageServiceHandler(BaseServiceHandler):
return
app.pt.setCell(offset, node, UP_TO_DATE_STATE)
app.pt.setCell(offset, node, CellStates.UP_TO_DATE)
new_cell_list.append(cell)
# If the partition contains a feeding cell, drop it now.
for feeding_cell in app.pt.getCellList(offset):
if feeding_cell.getState() == FEEDING_STATE:
if feeding_cell.getState() == CellStates.FEEDING:
app.pt.removeCell(offset, feeding_cell.getNode())
new_cell_list.append((offset, feeding_cell.getUUID(),
DISCARDED_STATE))
CellStates.DISCARDED))
break
if new_cell_list:
......
......@@ -17,7 +17,7 @@
import neo.pt
from struct import pack, unpack
from neo.protocol import OUT_OF_DATE_STATE, FEEDING_STATE, DISCARDED_STATE
from neo.protocol import CellStates
class PartitionTable(neo.pt.PartitionTable):
"""This class manages a partition table for the primary master node"""
......@@ -88,12 +88,12 @@ class PartitionTable(neo.pt.PartitionTable):
node_list = [c.getNode() for c in row]
n = self.findLeastUsedNode(node_list)
if n is not None:
row.append(neo.pt.Cell(n, OUT_OF_DATE_STATE))
row.append(neo.pt.Cell(n, CellStates.OUT_OF_DATE))
self.count_dict[n] += 1
cell_list.append((offset, n.getUUID(),
OUT_OF_DATE_STATE))
CellStates.OUT_OF_DATE))
row.remove(cell)
cell_list.append((offset, uuid, DISCARDED_STATE))
cell_list.append((offset, uuid, CellStates.DISCARDED))
break
try:
......@@ -134,8 +134,8 @@ class PartitionTable(neo.pt.PartitionTable):
continue
if num_cells <= self.nr:
row.append(neo.pt.Cell(node, OUT_OF_DATE_STATE))
cell_list.append((offset, node.getUUID(), OUT_OF_DATE_STATE))
row.append(neo.pt.Cell(node, CellStates.OUT_OF_DATE))
cell_list.append((offset, node.getUUID(), CellStates.OUT_OF_DATE))
node_count += 1
else:
if max_count - node_count > 1:
......@@ -144,18 +144,18 @@ class PartitionTable(neo.pt.PartitionTable):
# out-of-date, just drop the node.
row.remove(max_cell)
cell_list.append((offset, max_cell.getUUID(),
DISCARDED_STATE))
CellStates.DISCARDED))
self.count_dict[max_cell.getNode()] -= 1
else:
# Otherwise, use it as a feeding cell for safety.
max_cell.setState(FEEDING_STATE)
max_cell.setState(CellStates.FEEDING)
cell_list.append((offset, max_cell.getUUID(),
FEEDING_STATE))
CellStates.FEEDING))
# Don't count a feeding cell.
self.count_dict[max_cell.getNode()] -= 1
row.append(neo.pt.Cell(node, OUT_OF_DATE_STATE))
row.append(neo.pt.Cell(node, CellStates.OUT_OF_DATE))
cell_list.append((offset, node.getUUID(),
OUT_OF_DATE_STATE))
CellStates.OUT_OF_DATE))
node_count += 1
self.count_dict[node] = node_count
......@@ -220,7 +220,7 @@ class PartitionTable(neo.pt.PartitionTable):
row.remove(cell)
if not cell.isFeeding():
self.count_dict[cell.getNode()] -= 1
changed_cell_list.append((offset, cell.getUUID(), DISCARDED_STATE))
changed_cell_list.append((offset, cell.getUUID(), CellStates.DISCARDED))
# Add cells, if a row contains less than the number of replicas.
for offset, row in enumerate(self.partition_list):
......@@ -232,8 +232,8 @@ class PartitionTable(neo.pt.PartitionTable):
node = self.findLeastUsedNode([cell.getNode() for cell in row])
if node is None:
break
row.append(neo.pt.Cell(node, OUT_OF_DATE_STATE))
changed_cell_list.append((offset, node.getUUID(), OUT_OF_DATE_STATE))
row.append(neo.pt.Cell(node, CellStates.OUT_OF_DATE))
changed_cell_list.append((offset, node.getUUID(), CellStates.OUT_OF_DATE))
self.count_dict[node] += 1
num_cells += 1
......@@ -250,7 +250,7 @@ class PartitionTable(neo.pt.PartitionTable):
for offset, row in enumerate(self.partition_list):
for cell in row:
if not cell.getNode().isRunning() and not cell.isOutOfDate():
cell.setState(OUT_OF_DATE_STATE)
cell_list.append((offset, cell.getUUID(), OUT_OF_DATE_STATE))
cell.setState(CellStates.OUT_OF_DATE)
cell_list.append((offset, cell.getUUID(), CellStates.OUT_OF_DATE))
return cell_list
......@@ -318,26 +318,21 @@ error_codes = OldEnum({
})
class ClusterStates(Enum):
BOOTING = Enum.Item(1)
RECOVERING = Enum.Item(2)
VERIFYING = Enum.Item(3)
RUNNING = Enum.Item(4)
STOPPING = Enum.Item(5)
ClusterStates = ClusterStates()
class NodeTypes(Enum):
MASTER = Enum.Item(1)
STORAGE = Enum.Item(2)
CLIENT = Enum.Item(3)
ADMIN = Enum.Item(4)
NodeTypes = NodeTypes()
class NodeStates(Enum):
RUNNING = Enum.Item(1)
TEMPORARILY_DOWN = Enum.Item(2)
DOWN = Enum.Item(3)
......@@ -345,9 +340,15 @@ class NodeStates(Enum):
HIDDEN = Enum.Item(5)
PENDING = Enum.Item(6)
UNKNOWN = Enum.Item(7)
NodeStates = NodeStates()
class CellStates(Enum):
UP_TO_DATE = Enum.Item(1)
OUT_OF_DATE = Enum.Item(2)
FEEDING = Enum.Item(3)
DISCARDED = Enum.Item(4)
CellStates = CellStates()
# used for logging
node_state_prefix_dict = {
NodeStates.RUNNING: 'R',
......@@ -359,20 +360,12 @@ node_state_prefix_dict = {
NodeStates.UNKNOWN: 'U',
}
# Partition cell states.
cell_states = OldEnum({
'UP_TO_DATE_STATE': 0,
'OUT_OF_DATE_STATE': 1,
'FEEDING_STATE': 2,
'DISCARDED_STATE': 3,
})
# used for logging
cell_state_prefix_dict = {
UP_TO_DATE_STATE: 'U',
OUT_OF_DATE_STATE: 'O',
FEEDING_STATE: 'F',
DISCARDED_STATE: 'D',
CellStates.UP_TO_DATE: 'U',
CellStates.OUT_OF_DATE: 'O',
CellStates.FEEDING: 'F',
CellStates.DISCARDED: 'D',
}
# Other constants.
......@@ -693,7 +686,7 @@ def _decodeAnswerPartitionTable(body):
for j in xrange(m):
uuid, state = unpack('!16sH', body[index:index+18])
index += 18
state = cell_states.get(state)
state = CellStates.get(state)
uuid = _decodeUUID(uuid)
cell_list.append((uuid, state))
row_list.append((offset, tuple(cell_list)))
......@@ -714,7 +707,7 @@ def _decodeSendPartitionTable(body):
for j in xrange(m):
uuid, state = unpack('!16sH', body[index:index+18])
index += 18
state = cell_states.get(state)
state = CellStates.get(state)
uuid = _decodeUUID(uuid)
cell_list.append((uuid, state))
row_list.append((offset, tuple(cell_list)))
......@@ -729,7 +722,7 @@ def _decodeNotifyPartitionChanges(body):
cell_list = []
for i in xrange(n):
(offset, uuid, state) = unpack('!L16sH', body[12+i*22:34+i*22])
state = cell_states.get(state)
state = CellStates.get(state)
uuid = _decodeUUID(uuid)
cell_list.append((offset, uuid, state))
return ptid, cell_list
......@@ -1012,7 +1005,7 @@ def _decodeAnswerPartitionList(body):
for j in xrange(m):
uuid, state = unpack('!16sH', body[index:index+18])
index += 18
state = cell_states.get(state)
state = CellStates.get(state)
uuid = _decodeUUID(uuid)
cell_list.append((uuid, state))
row_list.append((offset, tuple(cell_list)))
......
......@@ -18,6 +18,7 @@
from neo import logging
from neo import protocol
from neo.protocol import CellStates
from neo.util import dump, u64
from neo.locking import RLock
......@@ -25,7 +26,7 @@ from neo.locking import RLock
class Cell(object):
"""This class represents a cell in a partition table."""
def __init__(self, node, state = protocol.UP_TO_DATE_STATE):
def __init__(self, node, state = CellStates.UP_TO_DATE):
self.node = node
self.state = state
......@@ -36,13 +37,13 @@ class Cell(object):
self.state = state
def isUpToDate(self):
return self.state == protocol.UP_TO_DATE_STATE
return self.state == CellStates.UP_TO_DATE
def isOutOfDate(self):
return self.state == protocol.OUT_OF_DATE_STATE
return self.state == CellStates.OUT_OF_DATE
def isFeeding(self):
return self.state == protocol.FEEDING_STATE
return self.state == CellStates.FEEDING
def getNode(self):
return self.node
......@@ -107,13 +108,13 @@ class PartitionTable(object):
def getCellList(self, offset, readable=False, writable=False):
# allow all cell states
state_set = set(protocol.cell_states.values())
state_set = set(CellStates.values())
if readable or writable:
# except non readables
state_set.remove(protocol.DISCARDED_STATE)
state_set.remove(CellStates.DISCARDED)
if readable:
# except non writables
state_set.remove(protocol.OUT_OF_DATE_STATE)
state_set.remove(CellStates.OUT_OF_DATE)
allowed_states = tuple(state_set)
try:
return [cell for cell in self.partition_list[offset] \
......@@ -133,7 +134,7 @@ class PartitionTable(object):
return index % self.np
def setCell(self, offset, node, state):
if state == protocol.DISCARDED_STATE:
if state == CellStates.DISCARDED:
return self.removeCell(offset, node)
if node.isBroken() or node.isDown():
return
......@@ -143,7 +144,7 @@ class PartitionTable(object):
if len(row) == 0:
# Create a new row.
row = [Cell(node, state), ]
if state != protocol.FEEDING_STATE:
if state != CellStates.FEEDING:
self.count_dict[node] += 1
self.partition_list[offset] = row
......@@ -158,7 +159,7 @@ class PartitionTable(object):
self.count_dict[node] -= 1
break
row.append(Cell(node, state))
if state != protocol.FEEDING_STATE:
if state != CellStates.FEEDING:
self.count_dict[node] += 1
def removeCell(self, offset, node):
......@@ -220,7 +221,7 @@ class PartitionTable(object):
DEBUG:root:pt: 00000009: U..U|.UU.|U..U|.UU.|U..U|.UU.|U..U|.UU.|U..U
Here, there are 4 nodes in RUNNING state.
The first partition has 2 replicas in UP_TO_DATE_STATE, on nodes 1 and
The first partition has 2 replicas in UP_TO_DATE state, on nodes 1 and
2 (nodes 0 and 3 are displayed as unused for that partition by
displaying a dot).
The 8-digits number on the left represents the number of the first
......
......@@ -20,7 +20,7 @@ import sys
from collections import deque
from neo import protocol
from neo.protocol import NodeTypes
from neo.protocol import NodeTypes, CellStates
from neo.node import NodeManager
from neo.event import EventManager
from neo.storage.mysqldb import MySQLDatabaseManager
......@@ -132,7 +132,7 @@ class Application(object):
new_cell_list = []
for offset, uuid, state in cell_list:
# convert from int to Enum
state = protocol.cell_states[state]
state = CellStates[state]
# register unknown nodes
if self.nm.getByUUID(uuid) is None:
self.nm.createStorage(uuid=uuid)
......
......@@ -18,8 +18,7 @@
from neo import logging
from neo.storage.handlers import BaseMasterHandler
from neo.protocol import DISCARDED_STATE, OUT_OF_DATE_STATE
from neo.protocol import NodeTypes, NodeStates
from neo.protocol import NodeTypes, NodeStates, CellStates
class HiddenHandler(BaseMasterHandler):
"""This class implements a generic part of the event handlers."""
......@@ -81,9 +80,9 @@ class HiddenHandler(BaseMasterHandler):
for offset, uuid, state in cell_list:
if uuid == app.uuid and app.replicator is not None:
# If this is for myself, this can affect replications.
if state == DISCARDED_STATE:
if state == CellStates.DISCARDED:
app.replicator.removePartition(offset)
elif state == OUT_OF_DATE_STATE:
elif state == CellStates.OUT_OF_DATE:
app.replicator.addPartition(offset)
def handleStartOperation(self, conn, packet):
......
......@@ -18,8 +18,8 @@
from neo import logging
from neo import protocol
from neo.protocol import CellStates
from neo.storage.handlers import BaseMasterHandler
from neo.protocol import DISCARDED_STATE, OUT_OF_DATE_STATE
from neo.exception import OperationFailure
......@@ -52,9 +52,9 @@ class MasterOperationHandler(BaseMasterHandler):
for offset, uuid, state in cell_list:
if uuid == app.uuid and app.replicator is not None:
# If this is for myself, this can affect replications.
if state == DISCARDED_STATE:
if state == CellStates.DISCARDED:
app.replicator.removePartition(offset)
elif state == OUT_OF_DATE_STATE:
elif state == CellStates.OUT_OF_DATE:
app.replicator.addPartition(offset)
def handleLockInformation(self, conn, packet, tid):
......
......@@ -25,7 +25,7 @@ from struct import pack, unpack
from neo.storage.database import DatabaseManager
from neo.exception import DatabaseFailure
from neo.protocol import DISCARDED_STATE
from neo.protocol import CellStates
from neo import util
LOG_QUERIES = False
......@@ -362,7 +362,7 @@ class MySQLDatabaseManager(DatabaseManager):
q("""TRUNCATE pt""")
for offset, uuid, state in cell_list:
uuid = e(util.dump(uuid))
if state == DISCARDED_STATE:
if state == CellStates.DISCARDED:
q("""DELETE FROM pt WHERE rid = %d AND uuid = '%s'""" \
% (offset, uuid))
else:
......
......@@ -20,8 +20,7 @@ from random import choice
from neo.storage.handlers import replication
from neo import protocol
from neo.protocol import UP_TO_DATE_STATE, OUT_OF_DATE_STATE
from neo.protocol import NodeTypes, NodeStates
from neo.protocol import NodeTypes, NodeStates, CellStates
from neo.connection import ClientConnection
from neo.util import dump
......@@ -107,7 +106,7 @@ class Replicator(object):
partition_dict = {}
for offset in xrange(app.pt.getPartitions()):
for uuid, state in app.pt.getRow(offset):
if uuid == app.uuid and state == OUT_OF_DATE_STATE:
if uuid == app.uuid and state == CellStates.OUT_OF_DATE:
partition_dict[offset] = Partition(offset)
return partition_dict
......@@ -197,7 +196,7 @@ class Replicator(object):
# Notify to a primary master node that my cell is now up-to-date.
conn = self.primary_master_connection
p = protocol.notifyPartitionChanges(app.pt.getID(),
[(self.current_partition.getRID(), app.uuid, UP_TO_DATE_STATE)])
[(self.current_partition.getRID(), app.uuid, CellStates.UP_TO_DATE)])
conn.notify(p)
except KeyError:
pass
......
......@@ -23,8 +23,7 @@ from neo.tests import NeoTestBase
from neo import protocol
from neo.pt import PartitionTable
from neo.protocol import UnexpectedPacketError, INVALID_UUID
from neo.protocol import NodeTypes, NodeStates, INVALID_PTID, \
UP_TO_DATE_STATE, FEEDING_STATE, DISCARDED_STATE
from neo.protocol import NodeTypes, NodeStates, CellStates, INVALID_PTID
from neo.client.handlers import BaseHandler
from neo.client.handlers.master import PrimaryBootstrapHandler
from neo.client.handlers.master import PrimaryNotificationsHandler, PrimaryAnswersHandler
......@@ -722,7 +721,7 @@ class ClientHandlerTests(NeoTestBase):
conn = self.getConnection(uuid=test_master_uuid)
test_storage_uuid = self.getNewUUID()
# TODO: use realistic values
test_cell_list = [(0, test_storage_uuid, UP_TO_DATE_STATE)]
test_cell_list = [(0, test_storage_uuid, CellStates.UP_TO_DATE)]
client_handler.handleNotifyPartitionChanges(conn, None, test_ptid + 1, test_cell_list)
# Check that a new node got added
add_call_list = app.nm.mockGetNamedCalls('add')
......@@ -751,10 +750,10 @@ class ClientHandlerTests(NeoTestBase):
client_handler = PrimaryNotificationsHandler(app, self.getDispatcher())
conn = self.getConnection(uuid=uuid1)
test_cell_list = [
(0, uuid1, UP_TO_DATE_STATE),
(0, uuid2, DISCARDED_STATE),
(0, uuid3, FEEDING_STATE),
(0, uuid4, UP_TO_DATE_STATE),
(0, uuid1, CellStates.UP_TO_DATE),
(0, uuid2, CellStates.DISCARDED),
(0, uuid3, CellStates.FEEDING),
(0, uuid4, CellStates.UP_TO_DATE),
]
client_handler.handleNotifyPartitionChanges(conn, None, test_ptid + 1, test_cell_list)
# Check that the three last node got added
......
......@@ -15,8 +15,6 @@
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
from neo.neoctl.neoctl import NeoCTL, NotReadyException
from neo import protocol
import os
import sys
import time
......@@ -28,7 +26,8 @@ import unittest
import tempfile
import traceback
from neo.protocol import ClusterStates, NodeTypes
from neo.neoctl.neoctl import NeoCTL, NotReadyException
from neo.protocol import ClusterStates, NodeTypes, CellStates
from neo.client.Storage import Storage
from neo.tests import getNewUUID
from neo.util import dump
......@@ -411,7 +410,7 @@ class NEOCluster(object):
number_of_oudated = 0
for row in row_list:
for cell in row[1]:
if cell[1] == protocol.OUT_OF_DATE_STATE:
if cell[1] == CellStates.OUT_OF_DATE:
number_of_oudated += 1
return number_of_oudated == number, number_of_oudated
self.expectCondition(callback, timeout, delay)
......
This diff is collapsed.
......@@ -22,7 +22,7 @@ from mock import Mock
from struct import pack, unpack
from neo.tests import NeoTestBase
from neo import protocol
from neo.protocol import Packet, NodeTypes, NodeStates, INVALID_UUID
from neo.protocol import Packet, NodeTypes, NodeStates, CellStates, INVALID_UUID
from neo.master.handlers.recovery import RecoveryHandler
from neo.master.app import Application
from neo.protocol import ERROR, REQUEST_NODE_IDENTIFICATION, ACCEPT_NODE_IDENTIFICATION, \
......@@ -39,11 +39,8 @@ from neo.protocol import ERROR, REQUEST_NODE_IDENTIFICATION, ACCEPT_NODE_IDENTIF
ABORT_TRANSACTION, ASK_STORE_TRANSACTION, ANSWER_STORE_TRANSACTION, \
ASK_OBJECT, ANSWER_OBJECT, ASK_TIDS, ANSWER_TIDS, ASK_TRANSACTION_INFORMATION, \
ANSWER_TRANSACTION_INFORMATION, ASK_OBJECT_HISTORY, ANSWER_OBJECT_HISTORY, \
ASK_OIDS, ANSWER_OIDS, \
NOT_READY_CODE, OID_NOT_FOUND_CODE, TID_NOT_FOUND_CODE, \
PROTOCOL_ERROR_CODE, BROKEN_NODE_DISALLOWED_CODE, \
INTERNAL_ERROR_CODE, \
UP_TO_DATE_STATE, OUT_OF_DATE_STATE, FEEDING_STATE, DISCARDED_STATE
ASK_OIDS, ANSWER_OIDS, NOT_READY_CODE, OID_NOT_FOUND_CODE, TID_NOT_FOUND_CODE, \
PROTOCOL_ERROR_CODE, BROKEN_NODE_DISALLOWED_CODE, INTERNAL_ERROR_CODE
from neo.exception import OperationFailure, ElectionFailure
from neo.tests import DoNothingConnector
from neo.connection import ClientConnection
......@@ -209,28 +206,28 @@ class MasterRecoveryTests(NeoTestBase):
conn = self.getFakeConnection(uuid, self.storage_port)
self.assertNotEquals(self.app.target_uuid, uuid)
offset = 1
cell_list = [(offset, uuid, UP_TO_DATE_STATE)]
cell_list = [(offset, uuid, CellStates.UP_TO_DATE)]
cells = self.app.pt.getRow(offset)
for cell, state in cells:
self.assertEquals(state, OUT_OF_DATE_STATE)
self.assertEquals(state, CellStates.OUT_OF_DATE)
recovery.handleAnswerPartitionTable(conn, packet, None, cell_list)
cells = self.app.pt.getRow(offset)
for cell, state in cells:
self.assertEquals(state, OUT_OF_DATE_STATE)
self.assertEquals(state, CellStates.OUT_OF_DATE)
# from target node, taken into account
conn = self.getFakeConnection(uuid, self.storage_port)
self.assertNotEquals(self.app.target_uuid, uuid)
self.app.target_uuid = uuid
self.assertEquals(self.app.target_uuid, uuid)
offset = 1
cell_list = [(offset, ((uuid, UP_TO_DATE_STATE,),),)]
cell_list = [(offset, ((uuid, CellStates.UP_TO_DATE,),),)]
cells = self.app.pt.getRow(offset)
for cell, state in cells:
self.assertEquals(state, OUT_OF_DATE_STATE)
self.assertEquals(state, CellStates.OUT_OF_DATE)
recovery.handleAnswerPartitionTable(conn, packet, None, cell_list)
cells = self.app.pt.getRow(offset)
for cell, state in cells:
self.assertEquals(state, UP_TO_DATE_STATE)
self.assertEquals(state, CellStates.UP_TO_DATE)
# give a bad offset, must send error
conn = self.getFakeConnection(uuid, self.storage_port)
self.assertEquals(self.app.target_uuid, uuid)
......
......@@ -23,15 +23,14 @@ from struct import pack, unpack
from neo.tests import NeoTestBase
import neo.master
from neo import protocol
from neo.protocol import Packet, NodeTypes, NodeStates, INVALID_UUID
from neo.protocol import Packet, NodeTypes, NodeStates, CellStates, INVALID_UUID
from neo.master.handlers.storage import StorageServiceHandler
from neo.master.app import Application
from neo.protocol import ERROR, PING, PONG, ANNOUNCE_PRIMARY_MASTER, \
REELECT_PRIMARY_MASTER, NOTIFY_NODE_INFORMATION, \
ASK_LAST_IDS, ANSWER_LAST_IDS, NOTIFY_PARTITION_CHANGES, \
ASK_UNFINISHED_TRANSACTIONS, ASK_BEGIN_TRANSACTION, FINISH_TRANSACTION, \
NOTIFY_INFORMATION_LOCKED, ASK_NEW_OIDS, ABORT_TRANSACTION, \
UP_TO_DATE_STATE, OUT_OF_DATE_STATE, FEEDING_STATE, DISCARDED_STATE
NOTIFY_INFORMATION_LOCKED, ASK_NEW_OIDS, ABORT_TRANSACTION
from neo.exception import OperationFailure, ElectionFailure
class MasterStorageHandlerTests(NeoTestBase):
......@@ -137,7 +136,7 @@ class MasterStorageHandlerTests(NeoTestBase):
for call in conn.mockGetAllCalls():
self.assertEquals(call.getName(), "getUUID")
sn = self.app.nm.getStorageList()[0]
self.assertEquals(sn.getState(), BROKEN_STATE)
self.assertEquals(sn.getState(), CellStates.BROKEN)
self.failUnless(ptid < self.app.pt.getID())
def test_06_handleAnswerLastIDs(self):
......@@ -257,53 +256,54 @@ class MasterStorageHandlerTests(NeoTestBase):
conn = self.getFakeConnection(uuid, self.storage_address)
storage_uuid = self.identifyToMasterNode(port=self.storage_port+1)
offset = 1
cell_list = [(offset, uuid, FEEDING_STATE),]
cell_list = [(offset, uuid, CellStates.FEEDING),]
cells = self.app.pt.getRow(offset)
for cell, state in cells:
self.assertEquals(state, OUT_OF_DATE_STATE)
self.assertEquals(state, CellStates.OUT_OF_DATE)
service.handleNotifyPartitionChanges(conn, packet, self.app.pt.getID(), cell_list)
cells = self.app.pt.getRow(offset)
for cell, state in cells:
self.assertEquals(state, OUT_OF_DATE_STATE)
self.assertEquals(state, CellStates.OUT_OF_DATE)
# send for another node, must not be take into account
conn = self.getFakeConnection(uuid, self.storage_address)
offset = 1
cell_list = [(offset, storage_uuid, UP_TO_DATE_STATE),]
cell_list = [(offset, storage_uuid, CellStates.UP_TO_DATE),]
cells = self.app.pt.getRow(offset)
for cell, state in cells:
self.assertEquals(state, OUT_OF_DATE_STATE)
self.assertEquals(state, CellStates.OUT_OF_DATE)
service.handleNotifyPartitionChanges(conn, packet, self.app.pt.getID(), cell_list)
cells = self.app.pt.getRow(offset)
for cell, state in cells:
self.assertEquals(state, OUT_OF_DATE_STATE)
self.assertEquals(state, CellStates.OUT_OF_DATE)
# send for itself, must be taken into account
# and the feeding node must be removed
conn = self.getFakeConnection(uuid, self.storage_address)
cell_list = [(offset, uuid, UP_TO_DATE_STATE),]
cell_list = [(offset, uuid, CellStates.UP_TO_DATE),]
cells = self.app.pt.getRow(offset)
for cell, state in cells:
self.assertEquals(state, OUT_OF_DATE_STATE)
self.assertEquals(state, CellStates.OUT_OF_DATE)
# mark the second storage node as feeding and say we are up to date
# second node must go to discarded state and first one to up to date state
self.app.pt.setCell(offset, self.app.nm.getByUUID(storage_uuid), FEEDING_STATE)
cell_list = [(offset, uuid, UP_TO_DATE_STATE),]
self.app.pt.setCell(offset, self.app.nm.getByUUID(storage_uuid),
CellStates.FEEDING)
cell_list = [(offset, uuid, CellStates.UP_TO_DATE),]
cells = self.app.pt.getRow(offset)
for cell, state in cells:
if cell == storage_uuid:
self.assertEquals(state, FEEDING_STATE)
self.assertEquals(state, CellStates.FEEDING)
else:
self.assertEquals(state, OUT_OF_DATE_STATE)
self.assertEquals(state, CellStates.OUT_OF_DATE)
lptid = self.app.pt.getID()
service.handleNotifyPartitionChanges(conn, packet, self.app.pt.getID(), cell_list)
self.failUnless(lptid < self.app.pt.getID())
cells = self.app.pt.getRow(offset)
for cell, state in cells:
if cell == uuid:
self.assertEquals(state, UP_TO_DATE_STATE)
self.assertEquals(state, CellStates.UP_TO_DATE)
else:
self.assertEquals(state, DISCARDED_STATE)
self.assertEquals(state, CellStates.DISCARDED)
def test_15_peerBroken(self):
......
......@@ -22,15 +22,14 @@ from mock import Mock
from struct import pack, unpack
import neo
from neo.tests import NeoTestBase
from neo.protocol import Packet, NodeTypes, NodeStates, INVALID_UUID
from neo.protocol import Packet, NodeTypes, NodeStates, CellStates, INVALID_UUID
from neo.master.handlers.verification import VerificationHandler
from neo.master.app import Application
from neo import protocol
from neo.protocol import ERROR, ANNOUNCE_PRIMARY_MASTER, \
NOTIFY_NODE_INFORMATION, ANSWER_LAST_IDS, ANSWER_PARTITION_TABLE, \
ANSWER_UNFINISHED_TRANSACTIONS, ANSWER_OBJECT_PRESENT, \
ANSWER_TRANSACTION_INFORMATION, OID_NOT_FOUND_CODE, TID_NOT_FOUND_CODE, \
UP_TO_DATE_STATE, OUT_OF_DATE_STATE, FEEDING_STATE, DISCARDED_STATE
ANSWER_TRANSACTION_INFORMATION, OID_NOT_FOUND_CODE, TID_NOT_FOUND_CODE
from neo.exception import OperationFailure, ElectionFailure, VerificationFailure
from neo.tests import DoNothingConnector
from neo.connection import ClientConnection
......
......@@ -24,8 +24,8 @@ from neo import protocol
from neo.pt import PartitionTable
from neo.storage.app import Application
from neo.storage.handlers.initialization import InitializationHandler
from neo.protocol import Packet, INVALID_UUID, \
UP_TO_DATE_STATE, INVALID_TID, PROTOCOL_ERROR_CODE
from neo.protocol import Packet, CellStates, INVALID_UUID, \
INVALID_TID, PROTOCOL_ERROR_CODE
from neo.protocol import ACCEPT_NODE_IDENTIFICATION, REQUEST_NODE_IDENTIFICATION, \
NOTIFY_PARTITION_CHANGES, STOP_OPERATION, ASK_LAST_IDS, ASK_PARTITION_TABLE, \
ANSWER_OBJECT_PRESENT, ASK_OBJECT_PRESENT, OID_NOT_FOUND_CODE, LOCK_INFORMATION, \
......@@ -108,9 +108,9 @@ class StorageInitializationHandlerTests(NeoTestBase):
self.app.nm.createStorage(uuid=node_2)
self.app.nm.createStorage(uuid=node_3)
self.assertEqual(self.app.dm.getPartitionTable(), [])
row_list = [(0, ((node_1, UP_TO_DATE_STATE), (node_2, UP_TO_DATE_STATE))),
(1, ((node_3, UP_TO_DATE_STATE), (node_1, UP_TO_DATE_STATE))),
(2, ((node_2, UP_TO_DATE_STATE), (node_3, UP_TO_DATE_STATE)))]
row_list = [(0, ((node_1, CellStates.UP_TO_DATE), (node_2, CellStates.UP_TO_DATE))),
(1, ((node_3, CellStates.UP_TO_DATE), (node_1, CellStates.UP_TO_DATE))),
(2, ((node_2, CellStates.UP_TO_DATE), (node_3, CellStates.UP_TO_DATE)))]
self.assertFalse(self.app.pt.filled())
# send part of the table, won't be filled
self