super early block explorer

BUILD

@@ -17,6 +17,14 @@ java_binary(
     ":minerlib",
   ]
 )
+java_binary(
+  name = "Shackleton",
+  main_class = "snowblossom.shackleton.Shackleton",
+  runtime_deps = [
+    ":shackletonlib",
+  ]
+)
+
 java_binary(
   name = "SnowBlossomClient",
   main_class = "snowblossom.client.SnowBlossomClient",
@@ -74,6 +82,19 @@ java_library(
   ],
 )
 
+java_library(
+  name = "shackletonlib",
+  srcs = glob(["src/shackleton/*.java"]),
+  deps = [
+    ":snowblossomprotolib",
+    ":snowblossomlib",
+    "@junit_junit//jar",
+    "@commons_codec//jar",
+    "@bcprov//jar",
+  ],
+)
+
+
 java_library(
   name = "clientlib",
   srcs = glob(["src/client/*.java"]),

WORKSPACE

@@ -42,8 +42,3 @@ maven_jar(
   sha1 = "2507204241ab450456bdb8e8c0a8f986e418bd99",
 )
 
-maven_jar(
-  name = "bitcoinj",
-  artifact = "org.bitcoinj:bitcoinj-core:0.14.7",
-  sha1 = "5e58d6921e1d8dfce81525b22c0de97f34be1f5c",
-)

src/MemPool.java

@@ -80,6 +80,11 @@ public MemPool(HashedTrie utxo_hashed_trie)
     new Tickler().start();
   }
 
+  public synchronized int getMemPoolSize()
+  {
+    return known_transactions.size();
+  }
+
   public synchronized TransactionMempoolInfo getRandomPoolTransaction()
   {
     ArrayList<TransactionMempoolInfo> list = new ArrayList<>();

src/Peerage.java

@@ -134,6 +134,14 @@ private PeerChainTip getTip()
     return tip.build();
   }
 
+  public int getConnectedPeerCount()
+  {
+    synchronized(links)
+    {
+      return links.size();
+    }
+  }
+
   private ImmutableList<PeerLink> getLinkList()
   {
     synchronized(links)
@@ -275,6 +283,7 @@ public void run()
       }
     }
 
+
     private void connectToPeers()
     {
       int connected = getLinkList().size();

src/SnowUserService.java

@@ -9,6 +9,8 @@
 import snowblossom.proto.SubmitReply;
 import snowblossom.proto.GetUTXONodeRequest;
 import snowblossom.proto.GetUTXONodeReply;
+import snowblossom.proto.NullRequest;
+import snowblossom.proto.NodeStatus;
 import snowblossom.trie.proto.TrieNode;
 import io.grpc.stub.StreamObserver;
 
@@ -195,6 +197,19 @@ public void getUTXONode(GetUTXONodeRequest request, StreamObserver<GetUTXONodeRe
     responseObserver.onCompleted();
   }
 
+  @Override
+  public void getNodeStatus(NullRequest null_request, StreamObserver<NodeStatus> responseObserver)
+  {
+    NodeStatus ns = NodeStatus.newBuilder()
+      .setMemPoolSize(node.getMemPool().getMemPoolSize())
+      .setConnectedPeers(node.getPeerage().getConnectedPeerCount())
+      .build();
+
+    responseObserver.onNext(ns);
+    responseObserver.onCompleted();
+
+  }
+
   class BlockSubscriberInfo
   {
     final AddressSpecHash mine_to;

src/shackleton/Shackleton.java

@@ -0,0 +1,79 @@
+package snowblossom.shackleton;
+
+import snowblossom.Config;
+import snowblossom.ConfigFile;
+import snowblossom.Globals;
+import snowblossom.LogSetup;
+
+import java.util.logging.Logger;
+import java.util.logging.Level;
+
+import io.grpc.ManagedChannel;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.stub.StreamObserver;
+
+import snowblossom.proto.UserServiceGrpc.UserServiceStub;
+import snowblossom.proto.UserServiceGrpc.UserServiceBlockingStub;
+import snowblossom.proto.UserServiceGrpc;
+
+import snowblossom.NetworkParams;
+
+
+/** Yes a penguin taught me french back in antacrtica */
+public class Shackleton
+{
+	private static final Logger logger = Logger.getLogger("snowblossom.shackleton");
+
+  public static void main(String args[])
+		throws Exception
+  {
+    Globals.addCryptoProvider();
+    if (args.length != 1)
+    {
+      logger.log(Level.SEVERE, "Incorrect syntax. Syntax: Shackleton <config_file>");
+      System.exit(-1);
+    }
+
+    ConfigFile config = new ConfigFile(args[0]);
+
+    LogSetup.setup(config);
+
+    new Shackleton(config);
+
+  }
+
+  private Config config;
+  private WebServer web_server;
+  private UserServiceStub asyncStub;
+  private UserServiceBlockingStub blockingStub;
+  private NetworkParams params;
+
+  public Shackleton(Config config)
+    throws Exception
+  {
+    this.config = config;
+
+    web_server = new WebServer(config, this);
+    config.require("node_host");
+
+    params = NetworkParams.loadFromConfig(config);
+
+    String host = config.get("node_host");
+    int port = config.getIntWithDefault("node_port", params.getDefaultPort());
+    ManagedChannel channel = ManagedChannelBuilder.forAddress(host, port).usePlaintext(true).build();
+
+    asyncStub = UserServiceGrpc.newStub(channel);
+    blockingStub = UserServiceGrpc.newBlockingStub(channel);
+
+    web_server.start();
+
+  }
+
+
+  public UserServiceBlockingStub getStub()
+  {
+    return blockingStub;
+  }
+
+
+}

src/shackleton/WebServer.java

@@ -0,0 +1,99 @@
+package snowblossom.shackleton;
+
+import snowblossom.Config;
+import java.util.Map;
+
+import java.net.InetSocketAddress;
+import com.sun.net.httpserver.HttpExchange;
+import com.sun.net.httpserver.HttpHandler;
+import com.sun.net.httpserver.HttpServer;
+import java.io.OutputStream;
+import java.io.IOException;
+import java.io.ByteArrayOutputStream;
+import java.io.PrintStream;
+
+import snowblossom.proto.UserServiceGrpc.UserServiceStub;
+import snowblossom.proto.NullRequest;
+
+public class WebServer
+{
+  private HttpServer server;
+  private Shackleton shackleton;
+
+  public WebServer(Config config, Shackleton shackleton)
+		throws Exception
+  {
+    this.shackleton = shackleton;
+
+    config.require("port");
+    int port = config.getInt("port");
+
+    server = HttpServer.create(new InetSocketAddress(port), 0);
+		server.createContext("/", new RootHandler());
+		server.createContext("/status", new RootHandler());
+		server.createContext("/test", new MyHandler());
+    server.setExecutor(null);
+
+
+  }
+
+  public void start()
+    throws java.io.IOException
+  {
+    server.start();
+
+
+  }
+    class RootHandler extends GeneralHandler
+    {
+      @Override
+      public void innerHandle(HttpExchange t, PrintStream out)
+      {
+        out.println(shackleton.getStub().getNodeStatus(nr()).toString());
+
+      }
+    }
+
+
+    static class MyHandler implements HttpHandler {
+        @Override
+        public void handle(HttpExchange t) throws IOException {
+            String response = "This is the response";
+            t.sendResponseHeaders(200, response.length());
+            OutputStream os = t.getResponseBody();
+            os.write(response.getBytes());
+            os.close();
+        }
+    }
+
+  public NullRequest nr()
+  {
+    return NullRequest.newBuilder().build();
+  }
+
+  public abstract class GeneralHandler implements HttpHandler
+  {
+    @Override
+    public void handle(HttpExchange t) throws IOException {
+      ByteArrayOutputStream b_out = new ByteArrayOutputStream();
+      PrintStream print_out = new PrintStream(b_out);
+      try
+      {
+        innerHandle(t, print_out);
+      }
+      catch(Throwable e)
+      {
+        print_out.println("Exception: " + e);
+      }
+
+      byte[] data = b_out.toByteArray();
+      t.sendResponseHeaders(200, data.length);
+      t.getResponseBody().write(data);
+
+
+    }
+
+    public abstract void innerHandle(HttpExchange t, PrintStream out) throws Exception;
+  }
+
+}