start refactoring - separate protocol engine from storage

Author: thsc42

src/net/sharksystem/asap/ASAPDefaultProtocolEngine.java

@@ -0,0 +1,37 @@
+package net.sharksystem.asap;
+
+import net.sharksystem.asap.protocol.ASAP_1_0;
+import net.sharksystem.asap.protocol.ASAP_AssimilationPDU_1_0;
+import net.sharksystem.asap.protocol.ASAP_Interest_PDU_1_0;
+import net.sharksystem.asap.protocol.ASAP_OfferPDU_1_0;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+public class ASAPDefaultProtocolEngine implements ASAPProtocolEngine {
+    @Override
+    public void handleASAPInterest(ASAP_Interest_PDU_1_0 asapInterest, ASAP_1_0 protocol, OutputStream os) throws ASAPException, IOException {
+
+    }
+
+    @Override
+    public void handleASAPOffer(ASAP_OfferPDU_1_0 asapOffer, ASAP_1_0 protocol, OutputStream os) throws ASAPException, IOException {
+
+    }
+
+    @Override
+    public void handleASAPAssimilate(ASAP_AssimilationPDU_1_0 asap_assimilation, ASAP_1_0 protocol, InputStream is, OutputStream os, ASAPChunkReceivedListener listener) throws ASAPException, IOException {
+
+    }
+
+    @Override
+    public void setBehaviourDropDeliveredChunks(boolean drop) throws IOException {
+
+    }
+
+    @Override
+    public void setBehaviourSendReceivedChunks(boolean on) throws IOException {
+
+    }
+}

src/net/sharksystem/asap/ASAPEngine.java

@@ -17,7 +17,7 @@
  * @see ASAPStorage
  * @author thsc
  */
-public abstract class ASAPEngine implements ASAPStorage, ASAPProtocolEngine, ASAPManagementStorage {
+public abstract class ASAPEngine extends ASAPStorageImpl implements ASAPStorage, ASAPProtocolEngine, ASAPManagementStorage {
     public static final String ANONYMOUS_OWNER = "anon";
     static String DEFAULT_OWNER = ANONYMOUS_OWNER;
     static int DEFAULT_INIT_ERA = 0;
@@ -71,6 +71,63 @@ public void detachASAPMessageAddListener() {
         this.asapOnlineMessageSender = null;
     }
 
+    /**
+     * We interpret an existing chunk with *no* recipients as
+     * public chunk
+     * @param chunk
+     * @return
+     */
+    private boolean isPublic(ASAPChunk chunk) {
+        return chunk.getRecipients().isEmpty();
+    }
+
+    @Override
+    public void newEra() {
+        StringBuilder sb = new StringBuilder();
+        sb.append(this.getLogStart());
+        sb.append("newEra() | owner: ");
+        sb.append(this.owner);
+        sb.append(" | format: ");
+        sb.append(this.format);
+        sb.append(" | ");
+
+        if(this.contentChanged) {
+            sb.append("content changed - increment era...");
+            System.out.println(sb.toString());
+            try {
+                int oldEra = this.era;
+                int nextEra = this.getNextEra(this.era);
+
+                // set as fast as possible to make race conditions less likely
+                this.contentChanged = false;
+
+                // we are done here - we are in a new era.
+                this.era = nextEra;
+
+                // persistent values
+                if(this.memento != null) this.memento.save(this);
+
+                // drop very very old chunks - if available
+                this.chunkStorage.dropChunks(nextEra);
+
+                // setup new era - copy all chunks
+                for(ASAPChunk chunk : this.chunkStorage.getChunks(oldEra)) {
+                    ASAPChunk copyChunk = this.chunkStorage.getChunk(chunk.getUri(), nextEra);
+                    copyChunk.clone(chunk);
+                }
+
+                System.out.println(this.getLogStart() + "era incremented");
+            } catch (IOException ex) {
+                sb.append("IOException while incrementing era: ");
+                sb.append(ex.getLocalizedMessage());
+                System.err.println(sb.toString());
+            }
+        } else {
+            sb.append("content not changed - era not changed");
+            System.out.println(sb.toString());
+        }
+    }
+
     //////////////////////////////////////////////////////////////////////
     //                               Writer                             //
     //////////////////////////////////////////////////////////////////////
@@ -288,38 +345,7 @@ private String getLogStart() {
 
         return b.toString();
     }
-/*
-    public void handleConnection(InputStream is, OutputStream os,
-                                 ASAPChunkReceivedListener listener) {
-
-        try {
-            ASAP_1_0 protocol = new ASAP_Modem_Impl();
-
-            // tell who I am - send a interest message
-            protocol.interest(this.owner, null, null,
-                    null, -1, -1, os, false);
 
-            // read interest from the other side
-            ASAP_PDU_1_0 asapPDU = protocol.readPDU(is);
-
-            // must be an interest
-            if(asapPDU.getCommand() != ASAP_1_0.INTEREST_CMD) {
-                throw new ASAPException("protocol error: expected asap interest - got something else");
-            }
-
-            this.handleASAPInterest((ASAP_Interest_PDU_1_0) asapPDU, protocol, os);
-        }
-        catch(Exception e) {
-            //<<<<<<<<<<<<<<<<<<debug
-            StringBuilder b = new StringBuilder();
-            b.append(this.getLogStart());
-            b.append("Exception: ");
-            b.append(e.getLocalizedMessage());
-            System.out.println(b.toString());
-            //>>>>>>>>>>>>>>>>>>>debug
-        }
-    }
-*/
     public void handleASAPOffer(ASAP_OfferPDU_1_0 asapOffer, ASAP_1_0 protocol, OutputStream os)
             throws ASAPException, IOException {
 
@@ -487,18 +513,6 @@ public void handleASAPInterest(ASAP_Interest_PDU_1_0 asapInterest, ASAP_1_0 prot
         System.out.println(b.toString());
         //>>>>>>>>>>>>>>>>>>>debug
 
-        // check conflict
-        if(!this.permission2ProceedConversation(peer)) {
-            b = new StringBuilder();
-            b.append(this.getLogStart());
-            b.append("no permission to communicate with remote peer: ");
-            b.append(peer);
-            System.err.println(b.toString());
-            throw new ASAPException("no permission to communicate with remote peer: " + peer);
-        } else {
-            System.out.println(this.getLogStart() + "permission ok, process interest");
-        }
-
         // era we are about to transmit
         int workingEra = this.getEraStartSync(peer);
         System.out.println(this.getLogStart() + "last_seen: " + workingEra + " | era: " + this.era);
@@ -564,7 +578,7 @@ private boolean isSendReceivedChunks() {
         return this.sendReceivedChunks;
     }
 
-    public void setSendReceivedChunks(boolean on) throws IOException {
+    public void setBehaviourSendReceivedChunks(boolean on) throws IOException {
         this.sendReceivedChunks = on;
         this.saveStatus();
     }
@@ -689,7 +703,7 @@ private boolean isDropDeliveredChunks() {
         return this.dropDeliveredChunks;
     }
 
-    public void setDropDeliveredChunks(boolean drop) throws IOException {
+    public void setBehaviourDropDeliveredChunks(boolean drop) throws IOException {
         this.dropDeliveredChunks = drop;
         this.saveStatus();
     }
@@ -727,101 +741,12 @@ public int getEra() {
         return this.era;
     }
 
+    @Override
     public CharSequence getFormat()  {
         return this.format;
     }
 
 
-//    public int getNextEra(int era) {
-//        return this.
-//    }
-    
-    /* old
-     * Peers in ad-hoc networks have the tendency to establish two channels
-     * simultaneously. It's due to the lack of a controlling server instance
-     * and the - wanted - equality of each peers. We should suppress those
-     * useless double conversations.
-     * 
-     * @param peer
-     * @return 
-     */
-
-    /**
-     * Security / Permission module is due to undergo a deep review - returns always true until than.
-     * @param peer
-     * @return
-     */
-    private synchronized boolean permission2ProceedConversation(String peer) {
-        return true;
-        // if that peer is not in the list - go ahead
-        /*
-        boolean goAhead = !this.activePeers.contains(peer);
-        if(goAhead) {
-            // add that peer - an other call will fail.
-            this.activePeers.add(peer);
-        }
-        
-        return goAhead;
-         */
-    }
-
-    /**
-     * We interpret an existing chunk with *no* recipients as
-     * public chunk
-     * @param chunk
-     * @return 
-     */
-    private boolean isPublic(ASAPChunk chunk) {
-        return chunk.getRecipients().isEmpty();
-    }
-
-    @Override
-    public void newEra() {
-        StringBuilder sb = new StringBuilder();
-        sb.append(this.getLogStart());
-        sb.append("newEra() | owner: ");
-        sb.append(this.owner);
-        sb.append(" | format: ");
-        sb.append(this.format);
-        sb.append(" | ");
-
-        if(this.contentChanged) {
-            sb.append("content changed - increment era...");
-            System.out.println(sb.toString());
-            try {
-                int oldEra = this.era;
-                int nextEra = this.getNextEra(this.era);
-
-                // set as fast as possible to make race conditions less likely
-                this.contentChanged = false;
-
-                // we are done here - we are in a new era.
-                this.era = nextEra;
-
-                // persistent values
-                if(this.memento != null) this.memento.save(this);
-
-                // drop very very old chunks - if available
-                this.chunkStorage.dropChunks(nextEra);
-
-                // setup new era - copy all chunks
-                for(ASAPChunk chunk : this.chunkStorage.getChunks(oldEra)) {
-                    ASAPChunk copyChunk = this.chunkStorage.getChunk(chunk.getUri(), nextEra);
-                    copyChunk.clone(chunk);
-                }
-
-                System.out.println(this.getLogStart() + "era incremented");
-            } catch (IOException ex) {
-                sb.append("IOException while incrementing era: ");
-                sb.append(ex.getLocalizedMessage());
-                System.err.println(sb.toString());
-            }
-        } else {
-            sb.append("content not changed - era not changed");
-            System.out.println(sb.toString());
-        }
-    }
-
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////
     //                                            Online management                                           //
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////

src/net/sharksystem/asap/ASAPProtocolEngine.java

@@ -26,17 +26,17 @@ void handleASAPAssimilate(ASAP_AssimilationPDU_1_0 asap_assimilation, ASAP_1_0 p
     /**
      * Chunks are (tried to be) delivered to their recipients during each encounter
      * with another peer. After successful delivery, recipient is withdrawn from recipient
-     * list to prevent mutliple delivery.
+     * list to prevent multiple delivery.
      *
      * If this flag is set, chunk are removed permanently if their are delivered
-     * to all their recipients. If no set, they remain intact.
+     * to all their recipients. There are kept in local storage otherwise.
      * @param drop
      */
-    void setDropDeliveredChunks(boolean drop) throws IOException;
+    void setBehaviourDropDeliveredChunks(boolean drop) throws IOException;
 
     /**
      * engine can deliver local message but also received messages - default false - send no received messages
      * @param on
      */
-    void setSendReceivedChunks(boolean on) throws IOException;
+    void setBehaviourSendReceivedChunks(boolean on) throws IOException;
 }

src/net/sharksystem/asap/ASAPSecurityException.java

@@ -0,0 +1,10 @@
+package net.sharksystem.asap;
+
+public class ASAPSecurityException extends ASAPException {
+    public ASAPSecurityException() {
+        super();
+    }
+    public ASAPSecurityException(String message) {
+        super(message);
+    }
+}

src/net/sharksystem/asap/ASAPStorage.java

@@ -123,7 +123,7 @@ public interface ASAPStorage {
      * are to be deleted.
      * @param drop
      */
-    void setDropDeliveredChunks(boolean drop) throws IOException;
+//    void setDropDeliveredChunks(boolean drop) throws IOException;
 
     /**
      * Chunks are delivered when seeing other peers. Default behaviour is to send only message which
@@ -133,7 +133,7 @@ public interface ASAPStorage {
      *
      * @param drop
      */
-    void setSendReceivedChunks(boolean drop) throws IOException;
+//    void setSendReceivedChunks(boolean drop) throws IOException;
 
     /**
      /**

src/net/sharksystem/asap/ASAPStorageImpl.java

@@ -0,0 +1,4 @@
+package net.sharksystem.asap;
+
+public abstract class ASAPStorageImpl implements ASAPStorage {
+}

src/net/sharksystem/asap/DefaultPeerSecurityAdministrator.java

@@ -0,0 +1,35 @@
+package net.sharksystem.asap;
+
+import java.io.IOException;
+
+public class DefaultPeerSecurityAdministrator implements PeerSecurityAdministrator, PeerSecuritySettings {
+    @Override
+    public void setRememberEncounteredPeers(boolean on) throws IOException {
+
+    }
+
+    @Override
+    public void setEncryptedMessagesOnly(boolean on) throws IOException {
+
+    }
+
+    @Override
+    public void setSignedMessagesOnly(boolean on) throws IOException {
+
+    }
+
+    @Override
+    public void setSetAllowedRemotePeers(AllowedRemotePeers safetyLevel) {
+
+    }
+
+    @Override
+    public boolean setRevealEngineFormat(String peerName) {
+        return false;
+    }
+
+    @Override
+    public boolean setSendOpenMessages(String peerName) {
+        return false;
+    }
+}

src/net/sharksystem/asap/PeerSecurityAdministrator.java

@@ -0,0 +1,4 @@
+package net.sharksystem.asap;
+
+interface PeerSecurityAdministrator {
+}