dfagent.java

网格agent平台(GAP ,Grid AgentsPlatform)开发包

		// - agent's history is null (will be instantiated on destination)
		// - new agent's destination resource ID is specified by actual
		// parameter for agentResourceID
		// - new agent's ID is unknown
		// - new agent's entity type is specified by actual parameter
		// for agentEntityType
		// - new agent's transfer size in bytes is specified by actual parameter
		// for SIZE
		// - new agent's AID is actually unknown so it's set to NOBODY
		agentRequest = new AgentRequest(this.get_id(), this.get_id(), null,
				agentResourceID, -1, agentEntityType, SIZE, agentResourceID,
				EntityTypes.NOBODY);
		// Passes the new instance of AgentRequest to method runAgent
		// because method runAgent is more general than method submitAgent
		return this.runAgent(agentRequest);
	}

	/**
	 * This method allows an agent to clone itself to another Grid Element
	 * keeping AID and agent history
	 *
	 * @TODO What happens to agent's gridlets?!?
	 *
	 * @param agentEntityType
	 *            agent entity type
	 * @param agentResourceID
	 *            Grid Element's resource ID
	 * @param SIZE
	 *            agent's transfer size in bytes
	 * @param AID
	 *            agent's AID
	 * @param agentHistory
	 *            agent's history
	 * @return an instance of class AgentReply
	 *
	 * @see net.p2pgrid.gap.agents.messages.AgentRequest
	 * @see net.p2pgrid.gap.agents.messages.AgentReply
	 * @see net.sf.gap.agents.history.AgentHistoryEntry
	 */
	private AgentReply submitAgent(int agentEntityType, int agentResourceID,
			int SIZE, int AID, AgentHistory agentHistory) {
		AgentRequest agentRequest = null;
		agentRequest = new AgentRequest(this.get_id(), this.getResourceID(),
				agentHistory, agentResourceID, -1, agentEntityType, SIZE,
				agentResourceID, AID);
		return this.runAgent(agentRequest);
	}

	/**
	 * Checks if current agent's state is congruent with a request
	 *
	 * @param ev
	 *            event received
	 * @return true if agent state is compatible with event received
	 *
	 * @see eduni.simjava.Sim_event
	 */
	private boolean isGoodState(Sim_event ev) {
		int agentState = this.getAgentState();
		switch (ev.get_tag()) {
		// Allowed state's transitions
		// ZOMBIE --> RUNNING
		case Tags.AGENT_RUN_REQ:
			return agentState == AgentStates.ZOMBIE;
			// RUNNING --> ZOMBIE
		case Tags.AGENT_KILL_REQ:
		case Tags.AGENT_KILLAWAIT_REQ:
			return (agentState == AgentStates.RUNNING);
			// RUNNING --> PAUSED
		case Tags.AGENT_PAUSE_REQ:
			return agentState == AgentStates.RUNNING;
			// PAUSED --> RUNNING
		case Tags.AGENT_RESUME_REQ:
			return agentState == AgentStates.PAUSED;
			// @TODO Check what happens to agent's state with MOVE and what is
			// preferable to happen
			// PAUSED --> MOVE --> RUNNING(?)
			// RUNNING --> MOVE --> RUNNING
		case Tags.AGENT_MOVE_REQ:
			return ((agentState == AgentStates.RUNNING) || (agentState == AgentStates.PAUSED))
					&& (!this.hasGridlets());
		default:
			return false;
		}
	}

	/**
	 * Updates agent according to event received and embedded request
	 *
	 * @param ev
	 *            event received
	 * @param agentRequest
	 *            the request embedded in such event
	 *
	 * @see eduni.simjava.Sim_event
	 * @see net.p2pgrid.gap.agents.messages.AgentRequest
	 * @see net.sf.gap.agents.history.AgentHistory
	 * @see net.sf.gap.agents.history.AgentHistoryEntry
	 */
	private void update(Sim_event ev, AgentRequest agentRequest) {
		AgentHistoryEntry agentHistoryEntry = null;
		switch (ev.get_tag()) {
		// DFAgent has received a RUN request
		case Tags.AGENT_RUN_REQ:
			// Checks that current agent's state is ZOMBIE
			Assert.assertEquals(this.getAgentState(), AgentStates.ZOMBIE);
			// Sets new agent's state to RUNNING
			this.setAgentState(AgentStates.RUNNING);
			// Updates agent's entity type
			this.setEntityType(agentRequest.getDst_entityType());
			// Updates agent's transfer size
			this.setAgentSizeInBytes(agentRequest.getDst_agentSize());
			// Checks that new agent has NOT yet an AID
			Assert.assertEquals(this.getAID() == EntityTypes.NOBODY, true);
			// if the new agent has NOT yet an AID
			if (agentRequest.getDst_AID() == EntityTypes.NOBODY) {
				// assigns a new AID
				this.assignAID();
				// otherwise, if the new agent has an old AID from a migration
			} else {
				// Sets agent's AID to the AID in
				// agentRequest's destination AID
				this.setAID(agentRequest.getDst_AID());
			}

			// Update agent's history with the following information:
			// - current simulation's clock
			// - new agent's name
			// - new agent's state
			// - new agent's ID
			// - new agent's AID
			// - new agent's entity type
			// - new agent's resource ID
			agentHistoryEntry = new AgentHistoryEntry(AbstractAgent.clock(),
					this.get_name(), this.getAgentState(), this.get_id(), this
							.getAID(), this.getEntityType(), this
							.getResourceID());
			// if agent is NOT really new (AID!=NOBODY) but the result
			// of a migration of an existing agent
			if (agentRequest.getDst_AID() != EntityTypes.NOBODY) {
				// carry with migrated agent its old agent's history
				this.getAgentHistory().addAll(
						agentRequest.getSrc_agentHistory());
			}
			// Updates agent's history with the new history entry
			this.getAgentHistory().add(agentHistoryEntry);
			// Updates agentRequest with current agent's AID
			agentRequest.setDst_AID(this.getAID());
			break;
		// DFAgent has received a KILL request
		case Tags.AGENT_KILL_REQ:
			// DFAgent has received a delayed KILL request
		case Tags.AGENT_KILLAWAIT_REQ:
			// Checks that current agent's state is RUNNING
			Assert.assertEquals(this.getAgentState(), AgentStates.RUNNING);
			// Sets agent's state to ZOMBIE
			this.setAgentState(AgentStates.ZOMBIE);
			// Checks that agent's entity type is NOT AGENT_ZOMBIE before
			// fulfilling current KILL request
			Assert.assertEquals(
					this.getEntityType() == EntityTypes.AGENT_ZOMBIE, false);
			// Sets agent's entity type to AGENT_ZOMBIE
			this.setEntityType(EntityTypes.AGENT_ZOMBIE);
			// Resets agent's transfer size to 0 bytes
			this.setAgentSizeInBytes(0);
			// Checks that agent had an AID before fulfilling
			// current KILL request
			Assert.assertEquals(this.getAID() == EntityTypes.NOBODY, false);
			// Detach AID from agent
			this.detachAID();

			// Update agent's history with the following information:
			// - current simulation's clock
			// - agent's name
			// - agent's state
			// - agent's ID
			// - agent's AID
			// - agent's entity type
			// - agent's resource ID
			agentHistoryEntry = new AgentHistoryEntry(AbstractAgent.clock(),
					this.get_name(), this.getAgentState(), this.get_id(), this
							.getAID(), this.getEntityType(), this
							.getResourceID());
			// Updates agent's history with the new history entry
			this.getAgentHistory().add(agentHistoryEntry);
			// Sets agent's AID to NOBODY
			agentRequest.setDst_AID(EntityTypes.NOBODY);
			break;
		// DFAgent has received a PAUSE request
		case Tags.AGENT_PAUSE_REQ:
			// Checks that agent's state is RUNNING
			Assert.assertEquals(this.getAgentState(), AgentStates.RUNNING);
			// Sets agent's state to PAUSED
			this.setAgentState(AgentStates.PAUSED);
			break;
		// DFAgent has received a RESUME request
		case Tags.AGENT_RESUME_REQ:
			// Checks that agent's state is PAUSED
			Assert.assertEquals(this.getAgentState(), AgentStates.PAUSED);
			// Sets agent's state to RUNNING
			this.setAgentState(AgentStates.RUNNING);
			break;
		default:
			break;
		}
	}

	/**
	 * Notify DF service about agent's request
	 *
	 * @param ev
	 *            event received
	 * @param agentRequest
	 *            request embedded in such request
	 *
	 * @see eduni.simjava.Sim_event
	 * @see net.p2pgrid.gap.agents.messages.AgentRequest
	 */
	private void notifyDF(Sim_event ev, AgentRequest agentRequest) {
		switch (ev.get_tag()) {
		// DFAgent has received a RUN request
		case Tags.AGENT_RUN_REQ:
			// Notifies DF to REGISTER agent
			this.notifyDFService(agentRequest, Tags.DF_REGISTER_REQ);
			break;
		// DFAgent has received a KILL request
		case Tags.AGENT_KILL_REQ:
			// DFAgent has received a delayed KILL request
		case Tags.AGENT_KILLAWAIT_REQ:
			// Notifies DF to DEREGISTER agent
			this.notifyDFService(agentRequest, Tags.DF_DEREGISTER_REQ);
			break;
		// DFAgent has received a PAUSE request
		case Tags.AGENT_PAUSE_REQ:
			// Notifies DF to PAUSE agent
			this.notifyDFService(agentRequest, Tags.DF_PAUSED_REQ);
			break;
		// DFAgent has received a RESUME request
		case Tags.AGENT_RESUME_REQ:
			// Notifies DF to RESUME agent
			this.notifyDFService(agentRequest, Tags.DF_RESUMED_REQ);
			break;
		default:
			break;
		}
	}

	/**
	 * This method is responsible for all submissions of new or migrated agents
	 *
	 * @param agentRequest
	 *            an instance of AgentRequest class specifying parameters of new
	 *            or migrated agent
	 * @return an instance of AgentReply class
	 *
	 * @see net.p2pgrid.gap.agents.messages.AgentRequest
	 * @see net.p2pgrid.gap.agents.messages.AgentReply
	 */
	protected AgentReply runAgent(AgentRequest agentRequest) {
		AgentReply agentReply = this.requestToAgent(agentRequest,
				Tags.AGENT_RUN_REQ);
		return agentReply;
	}

	/**
	 * This method is responsible to send a PAUSE request to an existing agent
	 *
	 * @param agentRequest
	 *            an instance of AgentRequest class specifying parameters the
	 *            agent to pause
	 * @return an instance of AgentReply class
	 *
	 * @see net.p2pgrid.gap.agents.messages.AgentRequest
	 * @see net.p2pgrid.gap.agents.messages.AgentReply
	 */
	protected AgentReply pauseAgent(AgentRequest agentRequest) {
		return this.requestToAgent(agentRequest, Tags.AGENT_PAUSE_REQ);
	}

	/**
	 * This method is responsible to send a RESUME request to an existing agent
	 *
	 * @param agentRequest
	 *            an instance of AgentRequest class specifying parameters the
	 *            agent to resume
	 * @return an instance of AgentReply class
	 *
	 * @see net.p2pgrid.gap.agents.messages.AgentRequest
	 * @see net.p2pgrid.gap.agents.messages.AgentReply
	 */
	protected AgentReply resumeAgent(AgentRequest agentRequest) {
		return this.requestToAgent(agentRequest, Tags.AGENT_RESUME_REQ);
	}

	/**
	 * This method is responsible to send a KILL request to an existing agent