[P2play-commit] SF.net SVN: p2play: [17] trunk/P2Play/src/org/p2play/net/pastry
Status: Pre-Alpha
Brought to you by:
tisoft
Menu
▾
▴
[P2play-commit] SF.net SVN: p2play: [17] trunk/P2Play/src/org/p2play/net/pastry
|
From: <ti...@us...> - 2006-12-30 20:30:20
|
Revision: 17
http://p2play.svn.sourceforge.net/p2play/?rev=17&view=rev
Author: tisoft
Date: 2006-12-30 12:30:03 -0800 (Sat, 30 Dec 2006)
Log Message:
-----------
transfered from university cvs
added license header
changed package name to org.p2play.*
Added Paths:
-----------
trunk/P2Play/src/org/p2play/net/pastry/NetworkHandler.java
trunk/P2Play/src/org/p2play/net/pastry/RegionScribe.java
Added: trunk/P2Play/src/org/p2play/net/pastry/NetworkHandler.java
===================================================================
--- trunk/P2Play/src/org/p2play/net/pastry/NetworkHandler.java (rev 0)
+++ trunk/P2Play/src/org/p2play/net/pastry/NetworkHandler.java 2006-12-30 20:30:03 UTC (rev 17)
@@ -0,0 +1,246 @@
+/*
+ * Copyright 2006 P2Play.org
+ * All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+package org.p2play.net.pastry;
+
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.logging.Level;
+
+import org.p2play.io.Serializer;
+import org.p2play.net.region.GameAction;
+import org.p2play.net.region.GameState;
+import org.p2play.net.region.Region;
+import org.p2play.net.region.RegionInstance;
+import org.p2play.net.region.RegionManager;
+import org.p2play.net.region.message.GameActionMessage;
+import org.p2play.net.region.message.GameStateHashMessage;
+import org.p2play.net.region.message.GameStateMessage;
+import org.p2play.net.region.message.JoinMessage;
+import org.p2play.net.region.message.MessageDeserializer;
+import org.p2play.net.region.message.RegionMessage;
+import org.p2play.util.ListMap;
+
+
+import rice.environment.logging.Logger;
+import rice.p2p.commonapi.Application;
+import rice.p2p.commonapi.Endpoint;
+import rice.p2p.commonapi.Id;
+import rice.p2p.commonapi.IdFactory;
+import rice.p2p.commonapi.Message;
+import rice.p2p.commonapi.Node;
+import rice.p2p.commonapi.NodeHandle;
+import rice.p2p.commonapi.RouteMessage;
+import rice.p2p.scribe.Scribe;
+import rice.p2p.scribe.ScribeClient;
+import rice.p2p.scribe.ScribeContent;
+import rice.p2p.scribe.Topic;
+
+public class NetworkHandler implements Application, ScribeClient {
+ private ListMap<Region, RegionInstance> regionInstanceMap;
+
+ private HashMap<RegionInstance, Topic> topicMap;
+
+ private Logger logger;
+
+ private Scribe scribe;
+
+ private IdFactory idFactory;
+
+ private Id nodeId;
+
+ private RegionManager regionManager;
+
+ private Endpoint endpoint;
+
+ private MessageDeserializer messageDeserializer;
+
+ private Serializer serializer;
+
+ public NetworkHandler(Serializer serializer, RegionManager regionManager, final Node node) {
+ this.serializer=serializer;
+ this.regionManager = regionManager;
+ this.regionInstanceMap = new ListMap<Region, RegionInstance>();
+ this.topicMap = new HashMap<RegionInstance, Topic>();
+ this.logger = node.getEnvironment().getLogManager().getLogger(
+ this.getClass(), "");
+ this.nodeId = node.getId();
+ this.idFactory = node.getIdFactory();
+ this.endpoint = node.buildEndpoint(this,
+ "region.controller.application");
+
+ this.endpoint.register();
+
+ messageDeserializer = new MessageDeserializer(this.serializer, this.endpoint);
+ this.endpoint.setDeserializer(messageDeserializer);
+
+ this.scribe = new RegionScribe(node, "region.controller.scribe", this);
+ scribe.setContentDeserializer(messageDeserializer);
+ }
+
+ public MessageDeserializer getMessageDeserializer() {
+ return messageDeserializer;
+ }
+
+ public void joinRegion(Region region, long gameTime) {
+ joinRegion(region, gameTime, 1);
+ }
+
+ public void joinRegion(Region region, long gameTime, int instances) {
+ // subscribe to the other instances
+ for (int i = 0; i < instances; i++) {
+ joinRegion(new RegionInstance(region, i), gameTime);
+ }
+ }
+
+ public void joinRegion(RegionInstance regionInstance, long gameTime) {
+ if (!regionInstanceMap.contains(regionInstance.getRegion(),
+ regionInstance)) {
+ java.util.logging.Logger.global.log(Level.INFO, "Joining "
+ + regionInstance);
+
+ // create topic:
+ regionInstanceMap.add(regionInstance.getRegion(), regionInstance);
+ // subscribe to the group
+ scribe.subscribe(getTopic(regionInstance), this, new JoinMessage(this.serializer,
+ nodeId, regionInstance, gameTime));
+
+ // ping the region controller
+ /*endpoint.route(getTopic(regionInstance).getId(), new JoinMessage(
+ nodeId, regionInstance, gameTime), null);*/
+ }
+ }
+
+ public void leaveRegion(Region region) {
+ System.out.println("*** Leaving: " + region);
+ Iterator<RegionInstance> iterator = regionInstanceMap.iterator(region);
+ while (iterator.hasNext()) {
+ RegionInstance regionInstance = iterator.next();
+ scribe.unsubscribe(getTopic(regionInstance), this);
+ iterator.remove();
+ }
+
+ }
+
+ public void sendGameState(Id id, GameState gameState) {
+ if (gameState != null) {
+ endpoint.route(id, new GameStateMessage(this.serializer,nodeId, gameState,
+ new RegionInstance(gameState.getRegion(), 0)), null);
+ }
+ }
+
+ public void sendGameState(GameState gameState, RegionInstance instance) {
+ if (gameState != null) {
+ scribe.publish(getTopic(instance), new GameStateMessage(this.serializer,nodeId,
+ gameState, instance));
+ }
+ }
+
+ public void sendGameState(GameState gameState) {
+ sendGameState(gameState, new RegionInstance(gameState.getRegion(), 0));
+ }
+
+ // send the hash of the gameState
+ public void sendGameStateHash(GameState gameState, RegionInstance instance) {
+ if (gameState != null) {
+ scribe.publish(getTopic(instance), new GameStateHashMessage(this.serializer, nodeId,
+ gameState, instance));
+ }
+ }
+
+ /**
+ * @param region
+ * @return
+ */
+ public Topic getTopic(RegionInstance regionInstance) {
+ Topic topic = topicMap.get(regionInstance);
+ if (topic == null) {
+ topic = new Topic(idFactory, regionInstance.toString());
+ topicMap.put(regionInstance, topic);
+ }
+ return topic;
+ }
+
+ public void sendInteraction(GameAction changeRequest) {
+ sendExtendedInteraction(changeRequest, -1, 0);
+ }
+
+ public void sendExtendedInteraction(GameAction changeRequest, long ticks,
+ int hash) {
+ synchronized (regionInstanceMap) {
+ Iterator<RegionInstance> topicIterator = regionInstanceMap
+ .iterator(changeRequest.getRegion());
+
+ while (topicIterator.hasNext()) {
+ RegionInstance topic = topicIterator.next();
+
+ if (!changeRequest.sendToAll()) {
+ endpoint.route(getTopic(topic).getId(),
+ new GameActionMessage(this.serializer, nodeId,
+ changeRequest, topic), null);
+ } else {
+ scribe.publish(getTopic(topic),
+ new GameActionMessage(this.serializer,nodeId,
+ changeRequest, topic));
+ }
+ }
+ }
+ }
+
+ public boolean forward(RouteMessage message) {
+ // logger.log("Forwarding message: " + message);
+ return true;
+ }
+
+ public void deliver(Id id, Message message) {
+ // logger.log("Got message: " + message + " from id: " + id);
+ regionManager.handleMessageReceived((RegionMessage) message);
+ }
+
+ public void update(NodeHandle handle, boolean joined) {
+
+ }
+
+ public boolean anycast(Topic topic, ScribeContent content) {
+ return false;
+ }
+
+ public void deliver(Topic topic, ScribeContent content) {
+ // logger.log("Got message: " + content + " in topic: " + topic);
+ regionManager.handleMessageReceived((RegionMessage) content);
+ }
+
+ public void childAdded(Topic topic, NodeHandle child) {
+
+ }
+
+ public void childRemoved(Topic topic, NodeHandle child) {
+
+ }
+
+ public void subscribeFailed(Topic topic) {
+ logger.log("Resubscribing to: " + topic);
+ // recubscribe
+ scribe.subscribe(topic, this);
+ }
+
+ public boolean isRoot(RegionInstance regionInstance) {
+ return scribe.isRoot(getTopic(regionInstance));
+ }
+
+}
\ No newline at end of file
Added: trunk/P2Play/src/org/p2play/net/pastry/RegionScribe.java
===================================================================
--- trunk/P2Play/src/org/p2play/net/pastry/RegionScribe.java (rev 0)
+++ trunk/P2Play/src/org/p2play/net/pastry/RegionScribe.java 2006-12-30 20:30:03 UTC (rev 17)
@@ -0,0 +1,41 @@
+package org.p2play.net.pastry;
+
+import java.io.IOException;
+
+
+import rice.p2p.commonapi.Message;
+import rice.p2p.commonapi.Node;
+import rice.p2p.commonapi.RouteMessage;
+import rice.p2p.scribe.ScribeImpl;
+import rice.p2p.scribe.messaging.SubscribeMessage;
+
+public class RegionScribe extends ScribeImpl {
+ private NetworkHandler networkHandler;
+
+ public RegionScribe(Node node, String instance, NetworkHandler networkHandler) {
+ super(node, instance);
+ this.networkHandler=networkHandler;
+ }
+
+ @Override
+ public boolean forward(RouteMessage routeMessage) {
+ boolean forward=super.forward(routeMessage);
+
+ try {
+ Message message=routeMessage.getMessage(endpoint.getDeserializer());
+
+ if (message instanceof SubscribeMessage) {
+ SubscribeMessage subscribeMessage = (SubscribeMessage) message;
+ if(isRoot(subscribeMessage.getTopic())){
+ System.out.println("Root: "+endpoint.getId()+" added "+subscribeMessage.getSource().getId()+" ... "+subscribeMessage.getContent());
+ networkHandler.deliver(endpoint.getId(), (Message) subscribeMessage.getContent());
+ }
+ }
+ } catch (IOException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+
+ return forward;
+ }
+}
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
