beehive.server

Class HashtableServerImpl

java.lang.Object

java.rmi.server.RemoteObject

java.rmi.server.RemoteServer

java.rmi.server.UnicastRemoteObject

beehive.server.HashtableServerImpl

All Implemented Interfaces:

HashtableServer, HashtableServer_thrift.Iface, Serializable, Remote

public class HashtableServerImpl
extends UnicastRemoteObject
implements HashtableServer, HashtableServer_thrift.Iface

See Also:

Serialized Form

Field Summary

Fields

Modifier and Type	Field and Description
float	CACHE_CLEANUP_TARGET
int	CACHE_TABLE_SIZE
int	CACHE_WINDOW
int	cacheInvalidationScheme
ConcurrentHashMap<String,Object>	cacheTable
int	changeMasterCount
ConcurrentHashMap<String,NodeMetadata>	metaDataTable
int	myId
String	myURL
static HashMap<Byte,Class>	nodeClassMap
static HashMap<Byte,String>	nodeClassNameMap
static HashMap<String,Byte>	nodeClassNametoIDMap
int	numServers
boolean	recordStats
ConcurrentHashMap<Integer,HashtableServer>	servers
boolean	USE_NODEDATA_REFLECTION
boolean	useCaching

Fields inherited from class java.rmi.server.RemoteObject

ref

Constructor Summary

Constructors

Constructor and Description
HashtableServerImpl(String url) server-id unaware contructor
HashtableServerImpl(String url, int serverId, Config configParams, boolean caching, HashMap<Byte,String> nodeClassNameMap, HashMap<Byte,Class> nodeClassMap) Constructor for the caching case

Method Summary

Modifier and Type	Method and Description
Node	cacheEvict(String nodeId) cache eviction thread invokes this method when removing a copy from the cache table (cache replacement)
void	cacheEvictMasterNotify(String cachingServerId, Hashtable<String,Long> evictedNodes) cache eviction thread invokes this method on the master site informing it of the cache eviction
void	cacheInvalidate(String nodeId) Master server invokes this function on a remote server when asking it to invalidate its cache copy
Vector<ResultObject>	cachePut(Map<Integer,Vector<Node>> nodes, long storageSystemThreadId) Bulk call for cachePut
ResultObject	cachePut(String nodeId, Node node, int masterCopySite, long storageSystemThreadId) Once a node has been fetched for caching, insert into cache table.
void	clearStatContainers() Clear stat containers
void	configureServer(Vector<String> hostList) Configure server to hold rmi handles of other servers Allows for inter-server communication
boolean	contains(String key) Check if the table contains a given key
void	enableStats() Turn on stat recording
ResultObject	exec(NodeData n) Executes the methods of a node contained in this server
Vector<ResultObject>	execBulk(Vector<NodeData> keyList)
ResultObject_thrift	get_thrift(String key, long storageSystemThreadId)
ResultObject	get(String key, long storageSystemThreadId) Given a node id, returns a node to the storage system (application) Forks off to getUseCache in the useCaching = true case
List<String>	getAllKeys_thrift()
Vector<String>	getAllKeys() Get all node ids present in the main table (does not include cache table)
Vector<Node>	getAllNodes() Get all nodes present in the main table (does not include cache table)
Vector<Node>	getCachedObjects(Vector<String> nodeIds)
ClusterMeasures	getClusterMeasures()
Vector<ResultObject>	getLocalNodes(Vector<String> nodeIds, long storageSystemThreadId) Storage system invokes this method on the server when requesting nodes and status for those nodes which are not available Only used in caching case
Node	getNodeForCaching(String nodeId, int cachingSite) Remote server invokes this method on the master site when requesting a cache copy
Node	getNodeFromCacheTable(String nodeId) get node for nodeId from the cache table returns null if node not found
Node	getNodeFromTable(String nodeId) get a node from the table
ResultObject_thrift	getNodeProperties_thrift(NodeData_thrift n)
ResultObject	getNodeProperties(NodeData n) retrieve the node data for a node, given its node ids and the required properties
Vector<Node>	getNodesForCaching(Vector<String> nodeIds, int cachingSite) Bulk call for getNodeForCaching
int	getNumServers()
List<ResultObject_thrift>	getObjects_thrift(List<String> keyList)
Vector<ResultObject>	getObjects(Vector<String> keyList) getObjects from the hash table.
List<ResultObject_thrift>	getObjectsProperties_thrift(List<NodeData_thrift> keyList)
Vector<ResultObject>	getObjectsProperties(Vector<NodeData> keyList) Bulk call to get object properties for a set of nodes
int	getServerId()
String	getStats() Get the stats, called after program run terminates
void	loadNodes(Vector<Node> nodes) To load initial nodes into the table, used by the file loader
void	locationChange_thrift(int nodeId, String serverName)
void	locationChange(int nodeId, String servername) Inform the homesite that a node has been relocated.
ResultObject_thrift	lock_thrift(int nodeId)
ResultObject	lock(int nodeId) Lock an object to prevent its relocation
static void	main(String[] args)
Date	ping() Test if the hashtable server is up
ResultObject_thrift	put_thrift(String key, Node_thrift value)
ResultObject	put(String key, Object value) Puts an object into the hashtable based on the provided key.
ResultObject	put(String key, Object value, int callerServerId) Puts an object into the cache and invalidates the cache of the calling server if needed.
List<ResultObject_thrift>	putObjects_thrift(Map<String,Node_thrift> nodeList_thrift)
Vector<ResultObject>	putObjects(ConcurrentHashMap<String,Node> objList) putObjects back into the hash table
Vector<ResultObject>	putObjects(ConcurrentHashMap<String,Node> objList, int callingServerId) put objects back into the hash table for the write through cache case
ResultObject	putUseCache(String key, Object value, int callingServerId) putUseCache for the write through cache case also takes in a calling server id, to keep track of cache invalidation (write through cache = no invalidation on calling server)
ResultObject_thrift	relocate_thrift(int nodeId, String serverName)
ResultObject	relocate(int nodeId, String serverName) called on the homesite when relocating a node to a remote server homesite makes a note of it in the location table
void	removeLocationTableEntry(String key) Remove a key from the location table
void	setNumServers(int n)
ResultObject_thrift	updateNodeProperties_thrift(NodeData_thrift n)
ResultObject	updateNodeProperties(NodeData value) update the properties of a node, given the node id and the updated property map
List<ResultObject_thrift>	updateNodePropertiesParallel_thrift(List<NodeData_thrift> keyList)
Vector<ResultObject>	updateNodePropertiesParallel(Vector<NodeData> objList) This is the reflection counterpart of putObjects, used for bulk update of node properties repeatedly calls the updateNodeProperties (can be done in parallel)
void	writeThroughToCache(String paramString, Object value) Writes an object to the local cache based on the paramString.
void	writeThroughToCacheBulk(ConcurrentHashMap<String,Node> map) bulk call for writeThroughToCache

Methods inherited from class java.rmi.server.UnicastRemoteObject

clone, exportObject, exportObject, exportObject, unexportObject

Methods inherited from class java.rmi.server.RemoteServer

getClientHost, getLog, setLog

Methods inherited from class java.rmi.server.RemoteObject

equals, getRef, hashCode, toString, toStub

Methods inherited from class java.lang.Object

finalize, getClass, notify, notifyAll, wait, wait, wait

Field Detail

myURL

public String myURL

myId

public int myId

cacheTable

public ConcurrentHashMap<String,Object> cacheTable

metaDataTable

public ConcurrentHashMap<String,NodeMetadata> metaDataTable

changeMasterCount

public int changeMasterCount

useCaching

public boolean useCaching

recordStats

public boolean recordStats

cacheInvalidationScheme

public int cacheInvalidationScheme

CACHE_TABLE_SIZE

public int CACHE_TABLE_SIZE

CACHE_WINDOW

public int CACHE_WINDOW

CACHE_CLEANUP_TARGET

public float CACHE_CLEANUP_TARGET

USE_NODEDATA_REFLECTION

public boolean USE_NODEDATA_REFLECTION

numServers

public int numServers

servers

public ConcurrentHashMap<Integer,HashtableServer> servers

nodeClassNameMap

public static HashMap<Byte,String> nodeClassNameMap

nodeClassMap

public static HashMap<Byte,Class> nodeClassMap

nodeClassNametoIDMap

public static HashMap<String,Byte> nodeClassNametoIDMap

Constructor Detail

HashtableServerImpl

public HashtableServerImpl(String url)
                    throws RemoteException

server-id unaware contructor

Parameters:

url -

Throws:

RemoteException

HashtableServerImpl

public HashtableServerImpl(String url,
                           int serverId,
                           Config configParams,
                           boolean caching,
                           HashMap<Byte,String> nodeClassNameMap,
                           HashMap<Byte,Class> nodeClassMap)
                    throws RemoteException

Constructor for the caching case

Parameters:

url -

serverId -

configParams -

Throws:

RemoteException

Method Detail

configureServer

public void configureServer(Vector<String> hostList)

Configure server to hold rmi handles of other servers Allows for inter-server communication

Parameters:

hostList -

enableStats

public void enableStats()

Turn on stat recording

ping

public Date ping()

Test if the hashtable server is up

Specified by:

ping in interface HashtableServer

Returns:

get

public ResultObject get(String key,
                        long storageSystemThreadId)

Given a node id, returns a node to the storage system (application) Forks off to getUseCache in the useCaching = true case

Specified by:

get in interface HashtableServer

Parameters:

key -

storageSystemThreadId -

Returns:

put

public ResultObject put(String key,
                        Object value)
                 throws RemoteException

Puts an object into the hashtable based on the provided key. If useCaching is true, then the object is put into the cache instead.

Specified by:

put in interface HashtableServer

Parameters:

key - The identifier of the object that is to be put into the hashtable.

value - The object that is to be put into the hashtable.

Returns:

A ResultObject describing the result of the put. If the object is placed into the hashtable for the first time, then the status is FAILED.

Throws:

RemoteException - Thrown only if useCaching is true and the object could not be put into cache.

put

public ResultObject put(String key,
                        Object value,
                        int callerServerId)
                 throws RemoteException

Puts an object into the cache and invalidates the cache of the calling server if needed.

Specified by:

put in interface HashtableServer

Parameters:

key - The identifier of the object that is be be put into cache.

value - The object that is be placed into cache.

callerServerId - The id of the server that called put.

Returns:

A ResultObject describing the result of the put. If the object is placed into the cache for the first time, then the status is FAILED.

Throws:

RemoteException - Thrown if the value could not be put into the cache.

See Also:

StorageSystem.putNodeUseCache(String, Node)

putUseCache

public ResultObject putUseCache(String key,
                                Object value,
                                int callingServerId)
                         throws RemoteException

putUseCache for the write through cache case also takes in a calling server id, to keep track of cache invalidation (write through cache = no invalidation on calling server)

Parameters:

key - The identifier of the object that is be be put into cache.

value - The object that is be placed into cache.

callingServerId - The id of the server that called put.

Returns:

A ResultObject describing the result of the put.

Throws:

RemoteException - Thrown if the object could not be put into cache

getNodeProperties

public ResultObject getNodeProperties(NodeData n)
                               throws RemoteException

retrieve the node data for a node, given its node ids and the required properties

Specified by:

getNodeProperties in interface HashtableServer

Parameters:

n -

Returns:

Throws:

RemoteException

updateNodeProperties

public ResultObject updateNodeProperties(NodeData value)
                                  throws RemoteException

update the properties of a node, given the node id and the updated property map

Specified by:

updateNodeProperties in interface HashtableServer

Parameters:

value -

Returns:

Throws:

RemoteException

exec

public ResultObject exec(NodeData n)
                  throws RemoteException

Executes the methods of a node contained in this server

Specified by:

exec in interface HashtableServer

Parameters:

n - - Contains the nodeId of the node whose methods are to be executed. The methods that are to be executed are provided as a mapping of method name to parameters.

Returns:

A ResultObject describing the results of the execution.

Throws:

RemoteException

execBulk

public Vector<ResultObject> execBulk(Vector<NodeData> keyList)
                              throws RemoteException

Specified by:

execBulk in interface HashtableServer

Throws:

RemoteException

getObjects

public Vector<ResultObject> getObjects(Vector<String> keyList)

getObjects from the hash table. Called only in non-caching case

Specified by:

getObjects in interface HashtableServer

Parameters:

keyList -

Returns:

putObjects

public Vector<ResultObject> putObjects(ConcurrentHashMap<String,Node> objList)
                                throws RemoteException

putObjects back into the hash table

Specified by:

putObjects in interface HashtableServer

Parameters:

objList -

Returns:

Throws:

RemoteException

putObjects

public Vector<ResultObject> putObjects(ConcurrentHashMap<String,Node> objList,
                                       int callingServerId)
                                throws RemoteException

put objects back into the hash table for the write through cache case

Specified by:

putObjects in interface HashtableServer

Parameters:

objList -

callingServerId -

Returns:

Throws:

RemoteException

getObjectsProperties

public Vector<ResultObject> getObjectsProperties(Vector<NodeData> keyList)
                                          throws RemoteException

Bulk call to get object properties for a set of nodes

Specified by:

getObjectsProperties in interface HashtableServer

Parameters:

keyList -

Returns:

Throws:

RemoteException

getCachedObjects

public Vector<Node> getCachedObjects(Vector<String> nodeIds)
                              throws RemoteException

Specified by:

getCachedObjects in interface HashtableServer

Throws:

RemoteException

updateNodePropertiesParallel

public Vector<ResultObject> updateNodePropertiesParallel(Vector<NodeData> objList)
                                                  throws RemoteException

This is the reflection counterpart of putObjects, used for bulk update of node properties repeatedly calls the updateNodeProperties (can be done in parallel)

Specified by:

updateNodePropertiesParallel in interface HashtableServer

Parameters:

objList - - hashtable of nodeId/Node data object

Returns:

result obects for reflection

Throws:

RemoteException

getNodeFromCacheTable

public Node getNodeFromCacheTable(String nodeId)
                           throws RemoteException

get node for nodeId from the cache table returns null if node not found

Specified by:

getNodeFromCacheTable in interface HashtableServer

Parameters:

nodeId -

Returns:

Throws:

RemoteException

cachePut

public ResultObject cachePut(String nodeId,
                             Node node,
                             int masterCopySite,
                             long storageSystemThreadId)

Once a node has been fetched for caching, insert into cache table.

Specified by:

cachePut in interface HashtableServer

Parameters:

nodeId -

node -

masterCopySite -

storageSystemThreadId -

Returns:

cachePut

public Vector<ResultObject> cachePut(Map<Integer,Vector<Node>> nodes,
                                     long storageSystemThreadId)

Bulk call for cachePut

Specified by:

cachePut in interface HashtableServer

Parameters:

nodes - - Map of master site v/s list of nodes obtained from that master site

storageSystemThreadId -

Returns:

cacheInvalidate

public void cacheInvalidate(String nodeId)

Master server invokes this function on a remote server when asking it to invalidate its cache copy

Specified by:

cacheInvalidate in interface HashtableServer

Parameters:

nodeId - - node for which invalidation has to take place

cacheEvict

public Node cacheEvict(String nodeId)

cache eviction thread invokes this method when removing a copy from the cache table (cache replacement)

Parameters:

nodeId -

Returns:

cacheEvictMasterNotify

public void cacheEvictMasterNotify(String cachingServerId,
                                   Hashtable<String,Long> evictedNodes)
                            throws RemoteException

cache eviction thread invokes this method on the master site informing it of the cache eviction

Specified by:

cacheEvictMasterNotify in interface HashtableServer

Parameters:

cachingServerId -

evictedNodes -

Throws:

RemoteException

getNodeForCaching

public Node getNodeForCaching(String nodeId,
                              int cachingSite)

Remote server invokes this method on the master site when requesting a cache copy

Specified by:

getNodeForCaching in interface HashtableServer

Parameters:

nodeId -

cachingSite -

Returns:

getNodesForCaching

public Vector<Node> getNodesForCaching(Vector<String> nodeIds,
                                       int cachingSite)

Bulk call for getNodeForCaching

Specified by:

getNodesForCaching in interface HashtableServer

writeThroughToCache

public void writeThroughToCache(String paramString,
                                Object value)

Writes an object to the local cache based on the paramString. The master does not need to invalidate the copy on put.

Specified by:

writeThroughToCache in interface HashtableServer

Parameters:

paramString - The identification of the value that is to be written to the cache

value - The object that is to be written to cache

writeThroughToCacheBulk

public void writeThroughToCacheBulk(ConcurrentHashMap<String,Node> map)

bulk call for writeThroughToCache

Specified by:

writeThroughToCacheBulk in interface HashtableServer

Parameters:

map -

getLocalNodes

public Vector<ResultObject> getLocalNodes(Vector<String> nodeIds,
                                          long storageSystemThreadId)

Storage system invokes this method on the server when requesting nodes and status for those nodes which are not available Only used in caching case

Specified by:

getLocalNodes in interface HashtableServer

Parameters:

nodeIds -

Returns:

getNodeFromTable

public Node getNodeFromTable(String nodeId)
                      throws RemoteException

get a node from the table

Specified by:

getNodeFromTable in interface HashtableServer

Parameters:

nodeId -

Returns:

Throws:

RemoteException

contains

public boolean contains(String key)

Check if the table contains a given key

Specified by:

contains in interface HashtableServer

Parameters:

key -

Returns:

getAllNodes

public Vector<Node> getAllNodes()

Get all nodes present in the main table (does not include cache table)

Specified by:

getAllNodes in interface HashtableServer

Returns:

getAllKeys

public Vector<String> getAllKeys()

Get all node ids present in the main table (does not include cache table)

Specified by:

getAllKeys in interface HashtableServer

Returns:

getStats

public String getStats()

Get the stats, called after program run terminates

Specified by:

getStats in interface HashtableServer

Returns:

clearStatContainers

public void clearStatContainers()

Clear stat containers

Specified by:

clearStatContainers in interface HashtableServer

loadNodes

public void loadNodes(Vector<Node> nodes)
               throws RemoteException

To load initial nodes into the table, used by the file loader

Specified by:

loadNodes in interface HashtableServer

Parameters:

nodes -

Throws:

RemoteException

getServerId

public int getServerId()
                throws RemoteException

Specified by:

getServerId in interface HashtableServer

Throws:

RemoteException

getNumServers

public int getNumServers()
                  throws RemoteException

Specified by:

getNumServers in interface HashtableServer

Throws:

RemoteException

setNumServers

public void setNumServers(int n)
                   throws RemoteException

Specified by:

setNumServers in interface HashtableServer

Throws:

RemoteException

relocate

public ResultObject relocate(int nodeId,
                             String serverName)

called on the homesite when relocating a node to a remote server homesite makes a note of it in the location table

Specified by:

relocate in interface HashtableServer

Parameters:

nodeId -

serverName -

Returns:

locationChange

public void locationChange(int nodeId,
                           String servername)

Inform the homesite that a node has been relocated. homesite makes a note of it in the location table and removes node from main table

Specified by:

locationChange in interface HashtableServer

Parameters:

nodeId -

servername -

lock

public ResultObject lock(int nodeId)
                  throws RemoteException

Lock an object to prevent its relocation

Specified by:

lock in interface HashtableServer

Parameters:

nodeId -

Returns:

Throws:

RemoteException

removeLocationTableEntry

public void removeLocationTableEntry(String key)

Remove a key from the location table

Specified by:

removeLocationTableEntry in interface HashtableServer

Parameters:

key -

getClusterMeasures

public ClusterMeasures getClusterMeasures()

Specified by:

getClusterMeasures in interface HashtableServer

main

public static void main(String[] args)
                 throws Exception

Throws:

Exception

put_thrift

public ResultObject_thrift put_thrift(String key,
                                      Node_thrift value)

Specified by:

put_thrift in interface HashtableServer_thrift.Iface

get_thrift

public ResultObject_thrift get_thrift(String key,
                                      long storageSystemThreadId)
                               throws org.apache.thrift.TException

Specified by:

get_thrift in interface HashtableServer_thrift.Iface

Throws:

org.apache.thrift.TException

getNodeProperties_thrift

public ResultObject_thrift getNodeProperties_thrift(NodeData_thrift n)
                                             throws org.apache.thrift.TException

Specified by:

getNodeProperties_thrift in interface HashtableServer_thrift.Iface

Throws:

org.apache.thrift.TException

updateNodeProperties_thrift

public ResultObject_thrift updateNodeProperties_thrift(NodeData_thrift n)
                                                throws org.apache.thrift.TException

Specified by:

updateNodeProperties_thrift in interface HashtableServer_thrift.Iface

Throws:

org.apache.thrift.TException

getObjectsProperties_thrift

public List<ResultObject_thrift> getObjectsProperties_thrift(List<NodeData_thrift> keyList)
                                                      throws org.apache.thrift.TException

Specified by:

getObjectsProperties_thrift in interface HashtableServer_thrift.Iface

Throws:

org.apache.thrift.TException

updateNodePropertiesParallel_thrift

public List<ResultObject_thrift> updateNodePropertiesParallel_thrift(List<NodeData_thrift> keyList)
                                                              throws org.apache.thrift.TException

Specified by:

updateNodePropertiesParallel_thrift in interface HashtableServer_thrift.Iface

Throws:

org.apache.thrift.TException

putObjects_thrift

public List<ResultObject_thrift> putObjects_thrift(Map<String,Node_thrift> nodeList_thrift)
                                            throws org.apache.thrift.TException

Specified by:

putObjects_thrift in interface HashtableServer_thrift.Iface

Throws:

org.apache.thrift.TException

getObjects_thrift

public List<ResultObject_thrift> getObjects_thrift(List<String> keyList)
                                            throws org.apache.thrift.TException

Specified by:

getObjects_thrift in interface HashtableServer_thrift.Iface

Throws:

org.apache.thrift.TException

getAllKeys_thrift

public List<String> getAllKeys_thrift()
                               throws org.apache.thrift.TException

Specified by:

getAllKeys_thrift in interface HashtableServer_thrift.Iface

Throws:

org.apache.thrift.TException

relocate_thrift

public ResultObject_thrift relocate_thrift(int nodeId,
                                           String serverName)
                                    throws org.apache.thrift.TException

Specified by:

relocate_thrift in interface HashtableServer_thrift.Iface

Throws:

org.apache.thrift.TException

locationChange_thrift

public void locationChange_thrift(int nodeId,
                                  String serverName)
                           throws org.apache.thrift.TException

Specified by:

locationChange_thrift in interface HashtableServer_thrift.Iface

Throws:

org.apache.thrift.TException

lock_thrift

public ResultObject_thrift lock_thrift(int nodeId)
                                throws org.apache.thrift.TException

Specified by:

lock_thrift in interface HashtableServer_thrift.Iface

Throws:

org.apache.thrift.TException