Support one cell to rejoin the tissue, with:

• already used certificate

• old DNA

• old Chain

• The dead cell eviction should then not remove the cell but put it in a AWOL state

Allow a new cell to without UDP access to the Tissue to join the tissue using the HTTP handler (TCP).

Embed all the repeated methods and attributes, make the implementation of a servlet service more simple.

Return a structure of the cells listening in the tissue with hostname and port, the service in the DNA is already available and being used the chain.

This will support to the mobile app to choose a cell to call TissueListenerTCP

This should be exposed as JSON

Defined the service discovery in the Tissue, use the already prepared diagrams.

In case the adopt cell fails the installed cell certificate should be removed

schemaLocation="http://localhost:1040/org/biosphere/tissue/DNA/TissueCellInterface-1.0.xsd

• Create new certificate sign request
• Call certificate sign from the tissue
• receives a new signed certificate from the tissue
• uses the certificate as client and server

The idea is to be able to track all the requests circuits, in that way is easy to trace when a request arrived where...

• Create keystore
• Create private key
• Create certificate sign request
• Sign its own certificate

Ensure the implementation of the stop/start of a service is working for both servlet and thread.

While receiving a request from a client should request the client certificate

Ensure that when the payload is not the expected one the mapper does not break

new Block(String flatBlock)

If mostly rejected that wait for the currentBlock to be changed

Should be the name of the remote cell

• append(String payload)
  • create a newBlock with the payload
  • choose one of the pending blocks of the currentBlock (choosenNextBlock)
  • update the nextBlock in the current block to the choosenBlock
  • change the currentBlock to the choosenBlock
  • set the newBlock as pendingBlock of the currentBlock
  • notify the tissue of the new block
• append(String JSONBlock)
  • check if the newBlock is valid
    • the prevBlock is the currentBlock or currentBlock pendingBlock
    • the calculated SHA-256 hash of the block matches provided hash
  • create a newBlock with the JSON
  • if the newBlock prevBlock is the currentBlock the add newBlock in the currentBlock's pendingBlocks
  • if the newBlock prevBlock is a pendingBlock of the currentBlock
    • update the nextBlock in the current block to the choosenBlock
    • change the currentBlock to the choosenBlock
    • set the newBlock as pendingBlock of the currentBlock
• Should check first for the acceptance of the block before appending (if mostly rejected that wait for the currentBlock to be changed)

• https://en.wikipedia.org/wiki/Two_Generals%27_Problem
• https://en.wikipedia.org/wiki/Byzantine_fault_tolerance
• https://en.wikipedia.org/wiki/Oracle_machine
• https://en.wikipedia.org/wiki/Blockchain_(database)
• https://bitsonblocks.net/2015/09/09/a-gentle-introduction-to-blockchain-technology/

Sign the block by signing the name of the cell that created the block using the cell private key

How to propagate the changes?

Does not accept the Welcome request twice, control if it is processing the Welcome request and if had already joined a Tissue

Check a better solution for the loggin into the application

• Support multi language
• Multiple logging levels

/*
ObjectMapper mapper = new ObjectMapper();

String flatInString=null;
String flatReturn=null;
try
{
  flatInString = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(this);
  flatReturn = mapper.writeValueAsString(this);
}
catch (JsonProcessingException e)
{
  e.printStackTrace();
}
System.out.println(flatInString);

return flatReturn;
*/

/**'

• Return one Block created from a String structure
• @param String
• @return
  /
  private Block blockFromFlat(String flatBlock)
  {
  /
  Block block = null;
  ObjectMapper mapper = new ObjectMapper();
  try
  {
  block = mapper.readValue(flatBlock, Block.class);
  //TODO check if the Hash of the just created block matches the hash sent, raise one exception in case fails
  }
  catch (JsonMappingException | JsonParseException e)
  {
  e.printStackTrace();
  }
  catch (IOException e)
  {
  e.printStackTrace();
  }
  return block;
  */
  return null;
  }

Support three messages (Greetings,Busy,AlreadyJoined)

TissueListener should be able to handle the different responses in a appropriate way.

• Security review!
• What should be public and what should be package visible?

Review the DNA to keep working with XML or move to JSON
JSON is easier to maintain and the structure of the DNA is not that complex right now.

Get ready in the API to the used by a mobile application

• save keystore
• save DNA
• save Chain

This will require the cell to be able to rejoin a tissue #44

Mostly parametrized Iterators...

Requires the DNA to support the byte code of the service in the classloader
The bytecode of the service will be stored in the DNA and loaded as needed when the service is instantiated.

When the chain block is received there should be a possibility to validate the payload of the block.

Joining cell is giving up before the acceptance was decided...

public final static long acceptanceTimeout = 2000L;
public final static long acceptanceInterval = 500L;
public final static int joinMaxRetries = 1;
public final static String joinPollInternval = "5000";

• remove the XML URL from the JSON payload
• send the DNA URL and the Chain URL in the same JSON payload

This will remove a two call procedure from the join tissue procedure.

blockID:timestamp:cellID:Base64(prevHash):prevBlockID:Base64(payload):Base64(blockHash):nextBlockID

Ensure the cell is removed from the DNA when shut down, the shutdown process should create a block to remove from the rest of the cells DNA

Chain is a attribute of Cell

Implement the service discovery protocol, this requires to have the service control start/stop to be working

flatChain format
<flatBlock>\n<flatBlock>\n<flatBlock>\n<flatBlock>\n<flatBlock>

Implement the maven-publish, upload to Maven Central

In the toFlat() method represent the prevHash and blockHash