Datasets:
jitx
/
Methods2Test_java_unit_test_code

Dataset card Data Studio Files Community
target
stringlengths
20
113k
src_fm
stringlengths
11
86.3k
src_fm_fc
stringlengths
21
86.4k
src_fm_fc_co
stringlengths
30
86.4k
src_fm_fc_ms
stringlengths
42
86.8k
src_fm_fc_ms_ff
stringlengths
43
86.8k
@Test public void testWithClientToken() { RunInstancesOptions options = withClientToken("some-token"); assertEquals(options.buildFormParameters().get("ClientToken"), ImmutableList.of("some-token")); }
public RunInstancesOptions withClientToken(String clientToken) { formParameters.put("ClientToken", checkNotNull(clientToken, "clientToken")); return this; }
RunInstancesOptions extends BaseEC2RequestOptions { public RunInstancesOptions withClientToken(String clientToken) { formParameters.put("ClientToken", checkNotNull(clientToken, "clientToken")); return this; } }
RunInstancesOptions extends BaseEC2RequestOptions { public RunInstancesOptions withClientToken(String clientToken) { formParameters.put("ClientToken", checkNotNull(clientToken, "clientToken")); return this; } }
RunInstancesOptions extends BaseEC2RequestOptions { public RunInstancesOptions withClientToken(String clientToken) { formParameters.put("ClientToken", checkNotNull(clientToken, "clientToken")); return this; } RunInstancesOptions withKeyName(String keyName); RunInstancesOptions withSecurityGroups(String... securityGroups); RunInstancesOptions withSecurityGroups(Iterable<String> securityGroups); RunInstancesOptions withSecurityGroup(String securityGroup); RunInstancesOptions withUserData(byte[] unencodedData); RunInstancesOptions asType(String type); RunInstancesOptions withKernelId(String kernelId); RunInstancesOptions withRamdisk(String ramDiskId); RunInstancesOptions withBlockDeviceMappings(Set<? extends BlockDeviceMapping> mappings); RunInstancesOptions withClientToken(String clientToken); }
RunInstancesOptions extends BaseEC2RequestOptions { public RunInstancesOptions withClientToken(String clientToken) { formParameters.put("ClientToken", checkNotNull(clientToken, "clientToken")); return this; } RunInstancesOptions withKeyName(String keyName); RunInstancesOptions withSecurityGroups(String... securityGroups); RunInstancesOptions withSecurityGroups(Iterable<String> securityGroups); RunInstancesOptions withSecurityGroup(String securityGroup); RunInstancesOptions withUserData(byte[] unencodedData); RunInstancesOptions asType(String type); RunInstancesOptions withKernelId(String kernelId); RunInstancesOptions withRamdisk(String ramDiskId); RunInstancesOptions withBlockDeviceMappings(Set<? extends BlockDeviceMapping> mappings); RunInstancesOptions withClientToken(String clientToken); static final RunInstancesOptions NONE; }
@Test(expectedExceptions = NullPointerException.class) public void testWithClientTokenNPE() { withClientToken(null); }
public RunInstancesOptions withClientToken(String clientToken) { formParameters.put("ClientToken", checkNotNull(clientToken, "clientToken")); return this; }
RunInstancesOptions extends BaseEC2RequestOptions { public RunInstancesOptions withClientToken(String clientToken) { formParameters.put("ClientToken", checkNotNull(clientToken, "clientToken")); return this; } }
RunInstancesOptions extends BaseEC2RequestOptions { public RunInstancesOptions withClientToken(String clientToken) { formParameters.put("ClientToken", checkNotNull(clientToken, "clientToken")); return this; } }
RunInstancesOptions extends BaseEC2RequestOptions { public RunInstancesOptions withClientToken(String clientToken) { formParameters.put("ClientToken", checkNotNull(clientToken, "clientToken")); return this; } RunInstancesOptions withKeyName(String keyName); RunInstancesOptions withSecurityGroups(String... securityGroups); RunInstancesOptions withSecurityGroups(Iterable<String> securityGroups); RunInstancesOptions withSecurityGroup(String securityGroup); RunInstancesOptions withUserData(byte[] unencodedData); RunInstancesOptions asType(String type); RunInstancesOptions withKernelId(String kernelId); RunInstancesOptions withRamdisk(String ramDiskId); RunInstancesOptions withBlockDeviceMappings(Set<? extends BlockDeviceMapping> mappings); RunInstancesOptions withClientToken(String clientToken); }
RunInstancesOptions extends BaseEC2RequestOptions { public RunInstancesOptions withClientToken(String clientToken) { formParameters.put("ClientToken", checkNotNull(clientToken, "clientToken")); return this; } RunInstancesOptions withKeyName(String keyName); RunInstancesOptions withSecurityGroups(String... securityGroups); RunInstancesOptions withSecurityGroups(Iterable<String> securityGroups); RunInstancesOptions withSecurityGroup(String securityGroup); RunInstancesOptions withUserData(byte[] unencodedData); RunInstancesOptions asType(String type); RunInstancesOptions withKernelId(String kernelId); RunInstancesOptions withRamdisk(String ramDiskId); RunInstancesOptions withBlockDeviceMappings(Set<? extends BlockDeviceMapping> mappings); RunInstancesOptions withClientToken(String clientToken); static final RunInstancesOptions NONE; }
@Test public void testPrivateNetworking() { TemplateOptions options = new DigitalOcean2TemplateOptions().privateNetworking(true); assertEquals(options.as(DigitalOcean2TemplateOptions.class).getPrivateNetworking(), true); }
public DigitalOcean2TemplateOptions privateNetworking(boolean privateNetworking) { this.privateNetworking = privateNetworking; return this; }
DigitalOcean2TemplateOptions extends TemplateOptions implements Cloneable { public DigitalOcean2TemplateOptions privateNetworking(boolean privateNetworking) { this.privateNetworking = privateNetworking; return this; } }
DigitalOcean2TemplateOptions extends TemplateOptions implements Cloneable { public DigitalOcean2TemplateOptions privateNetworking(boolean privateNetworking) { this.privateNetworking = privateNetworking; return this; } }
DigitalOcean2TemplateOptions extends TemplateOptions implements Cloneable { public DigitalOcean2TemplateOptions privateNetworking(boolean privateNetworking) { this.privateNetworking = privateNetworking; return this; } DigitalOcean2TemplateOptions privateNetworking(boolean privateNetworking); DigitalOcean2TemplateOptions backupsEnabled(boolean backupsEnabled); DigitalOcean2TemplateOptions sshKeyIds(Iterable<Integer> sshKeyIds); DigitalOcean2TemplateOptions autoCreateKeyPair(boolean autoCreateKeyPair); DigitalOcean2TemplateOptions userData(byte[] userData); @Deprecated @Override TemplateOptions userMetadata(Map<String, String> userMetadata); @Deprecated @Override TemplateOptions userMetadata(String key, String value); @Deprecated @Override Map<String, String> getUserMetadata(); Set<Integer> getSshKeyIds(); boolean getPrivateNetworking(); boolean getBackupsEnabled(); boolean getAutoCreateKeyPair(); byte[] getUserData(); @Override DigitalOcean2TemplateOptions clone(); @Override void copyTo(TemplateOptions to); @Override int hashCode(); @Override boolean equals(Object obj); @Override ToStringHelper string(); }
DigitalOcean2TemplateOptions extends TemplateOptions implements Cloneable { public DigitalOcean2TemplateOptions privateNetworking(boolean privateNetworking) { this.privateNetworking = privateNetworking; return this; } DigitalOcean2TemplateOptions privateNetworking(boolean privateNetworking); DigitalOcean2TemplateOptions backupsEnabled(boolean backupsEnabled); DigitalOcean2TemplateOptions sshKeyIds(Iterable<Integer> sshKeyIds); DigitalOcean2TemplateOptions autoCreateKeyPair(boolean autoCreateKeyPair); DigitalOcean2TemplateOptions userData(byte[] userData); @Deprecated @Override TemplateOptions userMetadata(Map<String, String> userMetadata); @Deprecated @Override TemplateOptions userMetadata(String key, String value); @Deprecated @Override Map<String, String> getUserMetadata(); Set<Integer> getSshKeyIds(); boolean getPrivateNetworking(); boolean getBackupsEnabled(); boolean getAutoCreateKeyPair(); byte[] getUserData(); @Override DigitalOcean2TemplateOptions clone(); @Override void copyTo(TemplateOptions to); @Override int hashCode(); @Override boolean equals(Object obj); @Override ToStringHelper string(); }
@Test public void testCar() throws Exception { Car car = getCar(); car.setPowerOn(); int tvalues[]= {-1,120,1000}; for (int tvalue:tvalues) { car.turn(new ServoPosition(tvalue,tvalue*10)); } int dvalues[]= {-1,150,1000}; for (int dvalue:dvalues) { car.drive(new ServoPosition(dvalue,dvalue*10)); } if (debug) servoCommand.showLog(); }
private Car() { if (servoCommand == null) { Environment env = Config.getEnvironment(); String servo_CommandConfig="servoblaster"; try { servo_CommandConfig = env.getString(Config.SERVO_COMMAND); } catch (Exception e) { ErrorHandler.getInstance().handle(e); } switch (servo_CommandConfig) { case "adafruit": try { servoCommand=new AdaFruit(); LOG.info("using AdaFruit ServoCommand handling"); } catch (Exception e) { ErrorHandler.getInstance().handle(e); } break; default: servoCommand = new ServoBlaster(); } } engine = new Engine(this, new EngineMap(servoCommand)); steering = new Steering(this, new SteeringMap(servoCommand)); led = new Led(new LedMap(servoCommand)); }
Car { private Car() { if (servoCommand == null) { Environment env = Config.getEnvironment(); String servo_CommandConfig="servoblaster"; try { servo_CommandConfig = env.getString(Config.SERVO_COMMAND); } catch (Exception e) { ErrorHandler.getInstance().handle(e); } switch (servo_CommandConfig) { case "adafruit": try { servoCommand=new AdaFruit(); LOG.info("using AdaFruit ServoCommand handling"); } catch (Exception e) { ErrorHandler.getInstance().handle(e); } break; default: servoCommand = new ServoBlaster(); } } engine = new Engine(this, new EngineMap(servoCommand)); steering = new Steering(this, new SteeringMap(servoCommand)); led = new Led(new LedMap(servoCommand)); } }
Car { private Car() { if (servoCommand == null) { Environment env = Config.getEnvironment(); String servo_CommandConfig="servoblaster"; try { servo_CommandConfig = env.getString(Config.SERVO_COMMAND); } catch (Exception e) { ErrorHandler.getInstance().handle(e); } switch (servo_CommandConfig) { case "adafruit": try { servoCommand=new AdaFruit(); LOG.info("using AdaFruit ServoCommand handling"); } catch (Exception e) { ErrorHandler.getInstance().handle(e); } break; default: servoCommand = new ServoBlaster(); } } engine = new Engine(this, new EngineMap(servoCommand)); steering = new Steering(this, new SteeringMap(servoCommand)); led = new Led(new LedMap(servoCommand)); } private Car(); }
Car { private Car() { if (servoCommand == null) { Environment env = Config.getEnvironment(); String servo_CommandConfig="servoblaster"; try { servo_CommandConfig = env.getString(Config.SERVO_COMMAND); } catch (Exception e) { ErrorHandler.getInstance().handle(e); } switch (servo_CommandConfig) { case "adafruit": try { servoCommand=new AdaFruit(); LOG.info("using AdaFruit ServoCommand handling"); } catch (Exception e) { ErrorHandler.getInstance().handle(e); } break; default: servoCommand = new ServoBlaster(); } } engine = new Engine(this, new EngineMap(servoCommand)); steering = new Steering(this, new SteeringMap(servoCommand)); led = new Led(new LedMap(servoCommand)); } private Car(); void configure(Engine engine, Steering steering, Led led); void setPowerOn(); void setPowerOff(); boolean powerIsOn(); void stop(); void turn(ServoPosition position); void drive(ServoPosition speed); Engine getEngine(); Steering getSteering(); Led getLed(); static Car getInstance(); static void resetInstance(); }
Car { private Car() { if (servoCommand == null) { Environment env = Config.getEnvironment(); String servo_CommandConfig="servoblaster"; try { servo_CommandConfig = env.getString(Config.SERVO_COMMAND); } catch (Exception e) { ErrorHandler.getInstance().handle(e); } switch (servo_CommandConfig) { case "adafruit": try { servoCommand=new AdaFruit(); LOG.info("using AdaFruit ServoCommand handling"); } catch (Exception e) { ErrorHandler.getInstance().handle(e); } break; default: servoCommand = new ServoBlaster(); } } engine = new Engine(this, new EngineMap(servoCommand)); steering = new Steering(this, new SteeringMap(servoCommand)); led = new Led(new LedMap(servoCommand)); } private Car(); void configure(Engine engine, Steering steering, Led led); void setPowerOn(); void setPowerOff(); boolean powerIsOn(); void stop(); void turn(ServoPosition position); void drive(ServoPosition speed); Engine getEngine(); Steering getSteering(); Led getLed(); static Car getInstance(); static void resetInstance(); static ServoCommand servoCommand; }
@Test public void testConfiguration() throws Exception { Configuration config=getMockConfiguration(); long nodeCount = config.g().V().count().next().longValue(); assertEquals(1,nodeCount); config.write(); assertTrue(config.getGraphFile().canRead()); config.getGraphFile().delete(); }
public Configuration(String graphFilePath, boolean readInis) { this.graphFilePath = graphFilePath; setGraph(TinkerGraph.open()); File graphFile = getGraphFile(); if (readInis) { fromIni(); write(); } else { if (graphFile.exists()) { read(graphFile); } } }
Configuration { public Configuration(String graphFilePath, boolean readInis) { this.graphFilePath = graphFilePath; setGraph(TinkerGraph.open()); File graphFile = getGraphFile(); if (readInis) { fromIni(); write(); } else { if (graphFile.exists()) { read(graphFile); } } } }
Configuration { public Configuration(String graphFilePath, boolean readInis) { this.graphFilePath = graphFilePath; setGraph(TinkerGraph.open()); File graphFile = getGraphFile(); if (readInis) { fromIni(); write(); } else { if (graphFile.exists()) { read(graphFile); } } } Configuration(String graphFilePath, boolean readInis); Configuration(); }
Configuration { public Configuration(String graphFilePath, boolean readInis) { this.graphFilePath = graphFilePath; setGraph(TinkerGraph.open()); File graphFile = getGraphFile(); if (readInis) { fromIni(); write(); } else { if (graphFile.exists()) { read(graphFile); } } } Configuration(String graphFilePath, boolean readInis); Configuration(); String getGraphFilePath(); void setGraphFilePath(String graphFilePath); void fromIni(); void addEnv(Environment env); TinkerGraph getGraph(); void setGraph(TinkerGraph graph); GraphTraversalSource g(); File getGraphFile(); void read(File graphFile); void write(File graphFile); String asString(); Map<String, Environment> getEnvironments(); Environment getEnvironmentFromVertex(Vertex v); void write(); }
Configuration { public Configuration(String graphFilePath, boolean readInis) { this.graphFilePath = graphFilePath; setGraph(TinkerGraph.open()); File graphFile = getGraphFile(); if (readInis) { fromIni(); write(); } else { if (graphFile.exists()) { read(graphFile); } } } Configuration(String graphFilePath, boolean readInis); Configuration(); String getGraphFilePath(); void setGraphFilePath(String graphFilePath); void fromIni(); void addEnv(Environment env); TinkerGraph getGraph(); void setGraph(TinkerGraph graph); GraphTraversalSource g(); File getGraphFile(); void read(File graphFile); void write(File graphFile); String asString(); Map<String, Environment> getEnvironments(); Environment getEnvironmentFromVertex(Vertex v); void write(); static String STORE_MODE; static String STORE_EXTENSION; }
@Test public void testEnvironment() throws Exception { String ip = "1.2.3.4"; int port = 8080; File propFile = setProperties(Config.REMOTECAR_HOST, ip, Config.WEBCONTROL_PORT, "" + port); Environment env = Config.getEnvironment(); String piIp = env.getString(Config.REMOTECAR_HOST); assertEquals(ip, piIp); assertFalse(env.isPi()); assertEquals(port, env.getInteger(Config.WEBCONTROL_PORT)); propFile.delete(); }
private Environment() { runningOnRaspberryPi = isPi(); }
Environment { private Environment() { runningOnRaspberryPi = isPi(); } }
Environment { private Environment() { runningOnRaspberryPi = isPi(); } private Environment(); Environment(String propFilePath); }
Environment { private Environment() { runningOnRaspberryPi = isPi(); } private Environment(); Environment(String propFilePath); static String readFirstLine(File file); static String osRelease(); boolean isPi(); static Environment getInstance(); boolean runningOnRaspberryPi(); Properties getProperties(); JsonObject asJsonObject(); static void from(JsonObject configJo); List<String> getMyIpAddresses(); String getString(String key); int getInteger(String key); double getDouble(String key); static void reset(); static void from(String propFilePath); static void mock(); }
Environment { private Environment() { runningOnRaspberryPi = isPi(); } private Environment(); Environment(String propFilePath); static String readFirstLine(File file); static String osRelease(); boolean isPi(); static Environment getInstance(); boolean runningOnRaspberryPi(); Properties getProperties(); JsonObject asJsonObject(); static void from(JsonObject configJo); List<String> getMyIpAddresses(); String getString(String key); int getInteger(String key); double getDouble(String key); static void reset(); static void from(String propFilePath); static void mock(); static String dukesHome; public String propFilePath; }
@Test public void testGetMyIpAddresses() { List<String> ips = Environment.getInstance().getMyIpAddresses(); assertNotNull(ips); assertTrue(ips.size() > 1); }
public List<String> getMyIpAddresses() { try { return Collections.list(NetworkInterface.getNetworkInterfaces()).stream() .map(iface -> Collections.list(iface.getInetAddresses())) .flatMap(Collection::stream).map(InetAddress::getHostAddress) .collect(Collectors.toList()); } catch (SocketException e) { LOG.error("Error while determining IP addresses: ", e); return null; } }
Environment { public List<String> getMyIpAddresses() { try { return Collections.list(NetworkInterface.getNetworkInterfaces()).stream() .map(iface -> Collections.list(iface.getInetAddresses())) .flatMap(Collection::stream).map(InetAddress::getHostAddress) .collect(Collectors.toList()); } catch (SocketException e) { LOG.error("Error while determining IP addresses: ", e); return null; } } }
Environment { public List<String> getMyIpAddresses() { try { return Collections.list(NetworkInterface.getNetworkInterfaces()).stream() .map(iface -> Collections.list(iface.getInetAddresses())) .flatMap(Collection::stream).map(InetAddress::getHostAddress) .collect(Collectors.toList()); } catch (SocketException e) { LOG.error("Error while determining IP addresses: ", e); return null; } } private Environment(); Environment(String propFilePath); }
Environment { public List<String> getMyIpAddresses() { try { return Collections.list(NetworkInterface.getNetworkInterfaces()).stream() .map(iface -> Collections.list(iface.getInetAddresses())) .flatMap(Collection::stream).map(InetAddress::getHostAddress) .collect(Collectors.toList()); } catch (SocketException e) { LOG.error("Error while determining IP addresses: ", e); return null; } } private Environment(); Environment(String propFilePath); static String readFirstLine(File file); static String osRelease(); boolean isPi(); static Environment getInstance(); boolean runningOnRaspberryPi(); Properties getProperties(); JsonObject asJsonObject(); static void from(JsonObject configJo); List<String> getMyIpAddresses(); String getString(String key); int getInteger(String key); double getDouble(String key); static void reset(); static void from(String propFilePath); static void mock(); }
Environment { public List<String> getMyIpAddresses() { try { return Collections.list(NetworkInterface.getNetworkInterfaces()).stream() .map(iface -> Collections.list(iface.getInetAddresses())) .flatMap(Collection::stream).map(InetAddress::getHostAddress) .collect(Collectors.toList()); } catch (SocketException e) { LOG.error("Error while determining IP addresses: ", e); return null; } } private Environment(); Environment(String propFilePath); static String readFirstLine(File file); static String osRelease(); boolean isPi(); static Environment getInstance(); boolean runningOnRaspberryPi(); Properties getProperties(); JsonObject asJsonObject(); static void from(JsonObject configJo); List<String> getMyIpAddresses(); String getString(String key); int getInteger(String key); double getDouble(String key); static void reset(); static void from(String propFilePath); static void mock(); static String dukesHome; public String propFilePath; }
@Test public void testMock() throws Exception { Environment.mock(); JsonObject jo = Environment.getInstance().asJsonObject(); String json = jo.toString(); if (debug) System.out.println(json); Environment env = Config.getEnvironment(); assertEquals(-20.0,env.getDouble(Config.WHEEL_MAX_LEFT_ANGLE),0.001); }
public static void mock() { Environment.from("../rc-drivecontrol/src/test/resources/dukes/dukes.ini"); }
Environment { public static void mock() { Environment.from("../rc-drivecontrol/src/test/resources/dukes/dukes.ini"); } }
Environment { public static void mock() { Environment.from("../rc-drivecontrol/src/test/resources/dukes/dukes.ini"); } private Environment(); Environment(String propFilePath); }
Environment { public static void mock() { Environment.from("../rc-drivecontrol/src/test/resources/dukes/dukes.ini"); } private Environment(); Environment(String propFilePath); static String readFirstLine(File file); static String osRelease(); boolean isPi(); static Environment getInstance(); boolean runningOnRaspberryPi(); Properties getProperties(); JsonObject asJsonObject(); static void from(JsonObject configJo); List<String> getMyIpAddresses(); String getString(String key); int getInteger(String key); double getDouble(String key); static void reset(); static void from(String propFilePath); static void mock(); }
Environment { public static void mock() { Environment.from("../rc-drivecontrol/src/test/resources/dukes/dukes.ini"); } private Environment(); Environment(String propFilePath); static String readFirstLine(File file); static String osRelease(); boolean isPi(); static Environment getInstance(); boolean runningOnRaspberryPi(); Properties getProperties(); JsonObject asJsonObject(); static void from(JsonObject configJo); List<String> getMyIpAddresses(); String getString(String key); int getInteger(String key); double getDouble(String key); static void reset(); static void from(String propFilePath); static void mock(); static String dukesHome; public String propFilePath; }
@Test public void testClusterStarter() throws Exception { Environment.mock(); ClusterStarter starter = new ClusterStarter(); TestVerticle testVerticle = new TestVerticle(); starter.deployVerticles(testVerticle); testVerticle.waitStatus(Status.started, ClusterStarter.MAX_START_TIME, 10); int minLoops=5; while (testVerticle.counter <=minLoops) { Thread.sleep(TestVerticle.TEST_INTERVAL_MS); } }
public void deployVerticles(AbstractVerticle... verticles) throws Exception { DeploymentOptions deploymentOptions = this.getDeployMentOptions(true); if (vertx == null) { this.clusteredVertx(resultHandler -> { vertx = resultHandler.result(); if (vertx == null) { ErrorHandler.getInstance().handle(new RuntimeException( "vertx not available resultHandler result is null")); } this.deployVerticles(deploymentOptions, verticles); }); } else { this.deployVerticles(deploymentOptions, verticles); } }
ClusterStarter { public void deployVerticles(AbstractVerticle... verticles) throws Exception { DeploymentOptions deploymentOptions = this.getDeployMentOptions(true); if (vertx == null) { this.clusteredVertx(resultHandler -> { vertx = resultHandler.result(); if (vertx == null) { ErrorHandler.getInstance().handle(new RuntimeException( "vertx not available resultHandler result is null")); } this.deployVerticles(deploymentOptions, verticles); }); } else { this.deployVerticles(deploymentOptions, verticles); } } }
ClusterStarter { public void deployVerticles(AbstractVerticle... verticles) throws Exception { DeploymentOptions deploymentOptions = this.getDeployMentOptions(true); if (vertx == null) { this.clusteredVertx(resultHandler -> { vertx = resultHandler.result(); if (vertx == null) { ErrorHandler.getInstance().handle(new RuntimeException( "vertx not available resultHandler result is null")); } this.deployVerticles(deploymentOptions, verticles); }); } else { this.deployVerticles(deploymentOptions, verticles); } } }
ClusterStarter { public void deployVerticles(AbstractVerticle... verticles) throws Exception { DeploymentOptions deploymentOptions = this.getDeployMentOptions(true); if (vertx == null) { this.clusteredVertx(resultHandler -> { vertx = resultHandler.result(); if (vertx == null) { ErrorHandler.getInstance().handle(new RuntimeException( "vertx not available resultHandler result is null")); } this.deployVerticles(deploymentOptions, verticles); }); } else { this.deployVerticles(deploymentOptions, verticles); } } Vertx getVertx(); void prepare(); void configureCluster(String clusterHostname,String publicHost); void clusteredVertx(Handler<AsyncResult<Vertx>> resultHandler); DeploymentOptions getDeployMentOptions(boolean worker); void deployVerticles(AbstractVerticle... verticles); VertxOptions getOptions(); void undeployVerticle(DukesVerticle verticle); String getHostname(); void setHostname(String hostname); }
ClusterStarter { public void deployVerticles(AbstractVerticle... verticles) throws Exception { DeploymentOptions deploymentOptions = this.getDeployMentOptions(true); if (vertx == null) { this.clusteredVertx(resultHandler -> { vertx = resultHandler.result(); if (vertx == null) { ErrorHandler.getInstance().handle(new RuntimeException( "vertx not available resultHandler result is null")); } this.deployVerticles(deploymentOptions, verticles); }); } else { this.deployVerticles(deploymentOptions, verticles); } } Vertx getVertx(); void prepare(); void configureCluster(String clusterHostname,String publicHost); void clusteredVertx(Handler<AsyncResult<Vertx>> resultHandler); DeploymentOptions getDeployMentOptions(boolean worker); void deployVerticles(AbstractVerticle... verticles); VertxOptions getOptions(); void undeployVerticle(DukesVerticle verticle); String getHostname(); void setHostname(String hostname); static final int MAX_START_TIME; }
@Test public void testErrorHandler() { String trace=null; try { throw new Exception("oops - a problem"); } catch (Throwable th) { trace=ErrorHandler.getStackTraceText(th); } assertNotNull(trace); assertTrue(trace.contains("oops - a problem")); assertTrue(trace.contains("TestErrorHandler.java:18")); }
public static String getStackTraceText(Throwable th) { StringWriter sw = new StringWriter(); PrintWriter pw = new PrintWriter(sw); th.printStackTrace(pw); String exceptionText = sw.toString(); return exceptionText; }
ErrorHandler { public static String getStackTraceText(Throwable th) { StringWriter sw = new StringWriter(); PrintWriter pw = new PrintWriter(sw); th.printStackTrace(pw); String exceptionText = sw.toString(); return exceptionText; } }
ErrorHandler { public static String getStackTraceText(Throwable th) { StringWriter sw = new StringWriter(); PrintWriter pw = new PrintWriter(sw); th.printStackTrace(pw); String exceptionText = sw.toString(); return exceptionText; } }
ErrorHandler { public static String getStackTraceText(Throwable th) { StringWriter sw = new StringWriter(); PrintWriter pw = new PrintWriter(sw); th.printStackTrace(pw); String exceptionText = sw.toString(); return exceptionText; } static String getStackTraceText(Throwable th); }
ErrorHandler { public static String getStackTraceText(Throwable th) { StringWriter sw = new StringWriter(); PrintWriter pw = new PrintWriter(sw); th.printStackTrace(pw); String exceptionText = sw.toString(); return exceptionText; } static String getStackTraceText(Throwable th); }
@Test public void testROI() throws Exception { if (!isTravis()) { NativeLibrary.load(); File imgRoot = new File(testPath); assertTrue(imgRoot.isDirectory()); Mat image = Imgcodecs.imread(testPath + "dukes_roi_test_image.jpg"); assertNotNull(image); assertEquals(960, image.height()); assertEquals(1280, image.width()); ROI rois[] = { new ROI("all", 0, 0, 1, 1), new ROI("far", 0, 0, 1, 0.5), new ROI("near", 0, 0.5, 1, 0.5), new ROI("left", 0, 0, 0.5, 1), new ROI("right", 0.5, 0, 0.5, 1) }; for (ROI roi : rois) { System.out.println(roi); Mat roiImage = roi.region(image); if (debug) System.out.println(String.format("%10s: %4d x %4d", roi.name, roiImage.width(), roiImage.height())); assertEquals(roiImage.width(), image.width() * roi.rw, 0.1); assertEquals(roiImage.height(), image.height() * roi.rh, 0.1); this.writeImage("dukes_roi_" + roi.name, roiImage); } } }
public ROI(String name,double rx, double ry, double rw, double rh) { this.name=name; this.rx = rx; this.ry = ry; this.rw = rw; this.rh = rh; }
ROI { public ROI(String name,double rx, double ry, double rw, double rh) { this.name=name; this.rx = rx; this.ry = ry; this.rw = rw; this.rh = rh; } }
ROI { public ROI(String name,double rx, double ry, double rw, double rh) { this.name=name; this.rx = rx; this.ry = ry; this.rw = rw; this.rh = rh; } ROI(String name,double rx, double ry, double rw, double rh); }
ROI { public ROI(String name,double rx, double ry, double rw, double rh) { this.name=name; this.rx = rx; this.ry = ry; this.rw = rw; this.rh = rh; } ROI(String name,double rx, double ry, double rw, double rh); Rect roiRect(Size base); Mat region(Mat image); String toString(); }
ROI { public ROI(String name,double rx, double ry, double rw, double rh) { this.name=name; this.rx = rx; this.ry = ry; this.rw = rw; this.rh = rh; } ROI(String name,double rx, double ry, double rw, double rh); Rect roiRect(Size base); Mat region(Mat image); String toString(); }
@Test public void testStraightLaneNavigator() { LaneDetectionResult ldrs[] = { getLdr(1, 0, -45., 0., 45.), getLdr(2, 100, -46., 1., 46.), getLdr(3, 200, -47., 0., 47.) }; StraightLaneNavigator nav = new StraightLaneNavigator(); for (LaneDetectionResult ldr : ldrs) nav.getNavigationInstruction(ldr); long nodeCount = nav.g().V().count().next().longValue(); assertEquals(3, nodeCount); }
public StraightLaneNavigator() { this(DEFAULT_TIME_WINDOW); }
StraightLaneNavigator extends TinkerPopDatabase implements Navigator { public StraightLaneNavigator() { this(DEFAULT_TIME_WINDOW); } }
StraightLaneNavigator extends TinkerPopDatabase implements Navigator { public StraightLaneNavigator() { this(DEFAULT_TIME_WINDOW); } StraightLaneNavigator(); StraightLaneNavigator(int timeWindow); }
StraightLaneNavigator extends TinkerPopDatabase implements Navigator { public StraightLaneNavigator() { this(DEFAULT_TIME_WINDOW); } StraightLaneNavigator(); StraightLaneNavigator(int timeWindow); DukesVerticle getSender(); void setSender(DukesVerticle sender); Vertex addToGraph(LaneDetectionResult ldr); @Override LaneDetectionResult fromJsonObject(JsonObject jo); boolean cmdOk(AngleRange angleRange, int minFound); void setTime(LaneDetectionResult ldr); void analyzeAngleRanges(int timeWindow, boolean showDebug); @Override JsonObject getNavigationInstruction(LaneDetectionResult ldr); JsonObject steerCommand(Double angle); @Override void navigateWithInstruction(JsonObject navigationInstruction); @Override void navigateWithMessage(Message<JsonObject> ldrMessage); @Override void navigateWithLaneDetectionResult(LaneDetectionResult ldr); @Override void videoStopped(VideoInfo videoInfo); }
StraightLaneNavigator extends TinkerPopDatabase implements Navigator { public StraightLaneNavigator() { this(DEFAULT_TIME_WINDOW); } StraightLaneNavigator(); StraightLaneNavigator(int timeWindow); DukesVerticle getSender(); void setSender(DukesVerticle sender); Vertex addToGraph(LaneDetectionResult ldr); @Override LaneDetectionResult fromJsonObject(JsonObject jo); boolean cmdOk(AngleRange angleRange, int minFound); void setTime(LaneDetectionResult ldr); void analyzeAngleRanges(int timeWindow, boolean showDebug); @Override JsonObject getNavigationInstruction(LaneDetectionResult ldr); JsonObject steerCommand(Double angle); @Override void navigateWithInstruction(JsonObject navigationInstruction); @Override void navigateWithMessage(Message<JsonObject> ldrMessage); @Override void navigateWithLaneDetectionResult(LaneDetectionResult ldr); @Override void videoStopped(VideoInfo videoInfo); static int COMMAND_LOOP_INTERVAL; static final int MAX_DURATION_NO_LINES_DETECTED; static final int DEFAULT_TIME_WINDOW; }
@Test public void testFromVideo() throws Exception { NativeLibrary.load(); Navigator nav = new StraightLaneNavigator(); String testUrl = "http: ImageFetcher imageFetcher = new ImageFetcher(testUrl); imageFetcher.open(); int frameIndex = 0; int maxFrameIndex = 300; while (frameIndex < maxFrameIndex && imageFetcher.hasNext() && !imageFetcher.isClosed()) { Image image = imageFetcher.fetch(); frameIndex = image.getFrameIndex(); System.out.println(frameIndex); if (imageFetcher.hasNext()) { LaneDetector laneDetector = LaneDetector.getDefault(); LaneDetectionResult ldr = laneDetector.detect(image); if (debug) System.out.println(ldr.debugInfo()); JsonObject navJo = nav.getNavigationInstruction(ldr); if (navJo != null) System.out.println(navJo.encodePrettily()); } } imageFetcher.close(); long nodeCount = nav.g().V().count().next().longValue(); assertEquals(maxFrameIndex, nodeCount); }
@Override public JsonObject getNavigationInstruction(LaneDetectionResult ldr) { JsonObject message = null; if (this.emergencyStopActivated) return message; setTime(ldr); Vertex ldrVertex=addToGraph(ldr); boolean showDebug = true; analyzeAngleRanges(timeWindow, showDebug); if (currentTime - startTime > MAX_DURATION_NO_LINES_DETECTED && stopRangeLeft.count + stopRangeRight.count == 0 || emergencyStopActivated) { this.emergencyStopActivated = true; return ActionVerticle.emergencyStopCommand(); } int MIN_FOUND_PER_TIMEWINDOW = 3; AngleRange navigateRange = null; if (middleRange.count >= MIN_FOUND_PER_TIMEWINDOW) { navigateRange = courseRange; } else { navigateRange = leftRange.count > rightRange.count ? leftRange : rightRange; } if (this.cmdOk(navigateRange, MIN_FOUND_PER_TIMEWINDOW)) { double angle = navigateRange.steer(); String msg = ldr.debugInfo() + String.format("\nsteer by %s: %s", navigateRange.name, Line.angleString(angle)); LOG.debug(msg); ldrVertex.property("steer",angle); ldrVertex.property("steerBy",navigateRange.name); ldrVertex.property("debugInfo",msg); tsLatestCommand = currentTime; message = steerCommand(angle); } return message; }
StraightLaneNavigator extends TinkerPopDatabase implements Navigator { @Override public JsonObject getNavigationInstruction(LaneDetectionResult ldr) { JsonObject message = null; if (this.emergencyStopActivated) return message; setTime(ldr); Vertex ldrVertex=addToGraph(ldr); boolean showDebug = true; analyzeAngleRanges(timeWindow, showDebug); if (currentTime - startTime > MAX_DURATION_NO_LINES_DETECTED && stopRangeLeft.count + stopRangeRight.count == 0 || emergencyStopActivated) { this.emergencyStopActivated = true; return ActionVerticle.emergencyStopCommand(); } int MIN_FOUND_PER_TIMEWINDOW = 3; AngleRange navigateRange = null; if (middleRange.count >= MIN_FOUND_PER_TIMEWINDOW) { navigateRange = courseRange; } else { navigateRange = leftRange.count > rightRange.count ? leftRange : rightRange; } if (this.cmdOk(navigateRange, MIN_FOUND_PER_TIMEWINDOW)) { double angle = navigateRange.steer(); String msg = ldr.debugInfo() + String.format("\nsteer by %s: %s", navigateRange.name, Line.angleString(angle)); LOG.debug(msg); ldrVertex.property("steer",angle); ldrVertex.property("steerBy",navigateRange.name); ldrVertex.property("debugInfo",msg); tsLatestCommand = currentTime; message = steerCommand(angle); } return message; } }
StraightLaneNavigator extends TinkerPopDatabase implements Navigator { @Override public JsonObject getNavigationInstruction(LaneDetectionResult ldr) { JsonObject message = null; if (this.emergencyStopActivated) return message; setTime(ldr); Vertex ldrVertex=addToGraph(ldr); boolean showDebug = true; analyzeAngleRanges(timeWindow, showDebug); if (currentTime - startTime > MAX_DURATION_NO_LINES_DETECTED && stopRangeLeft.count + stopRangeRight.count == 0 || emergencyStopActivated) { this.emergencyStopActivated = true; return ActionVerticle.emergencyStopCommand(); } int MIN_FOUND_PER_TIMEWINDOW = 3; AngleRange navigateRange = null; if (middleRange.count >= MIN_FOUND_PER_TIMEWINDOW) { navigateRange = courseRange; } else { navigateRange = leftRange.count > rightRange.count ? leftRange : rightRange; } if (this.cmdOk(navigateRange, MIN_FOUND_PER_TIMEWINDOW)) { double angle = navigateRange.steer(); String msg = ldr.debugInfo() + String.format("\nsteer by %s: %s", navigateRange.name, Line.angleString(angle)); LOG.debug(msg); ldrVertex.property("steer",angle); ldrVertex.property("steerBy",navigateRange.name); ldrVertex.property("debugInfo",msg); tsLatestCommand = currentTime; message = steerCommand(angle); } return message; } StraightLaneNavigator(); StraightLaneNavigator(int timeWindow); }
StraightLaneNavigator extends TinkerPopDatabase implements Navigator { @Override public JsonObject getNavigationInstruction(LaneDetectionResult ldr) { JsonObject message = null; if (this.emergencyStopActivated) return message; setTime(ldr); Vertex ldrVertex=addToGraph(ldr); boolean showDebug = true; analyzeAngleRanges(timeWindow, showDebug); if (currentTime - startTime > MAX_DURATION_NO_LINES_DETECTED && stopRangeLeft.count + stopRangeRight.count == 0 || emergencyStopActivated) { this.emergencyStopActivated = true; return ActionVerticle.emergencyStopCommand(); } int MIN_FOUND_PER_TIMEWINDOW = 3; AngleRange navigateRange = null; if (middleRange.count >= MIN_FOUND_PER_TIMEWINDOW) { navigateRange = courseRange; } else { navigateRange = leftRange.count > rightRange.count ? leftRange : rightRange; } if (this.cmdOk(navigateRange, MIN_FOUND_PER_TIMEWINDOW)) { double angle = navigateRange.steer(); String msg = ldr.debugInfo() + String.format("\nsteer by %s: %s", navigateRange.name, Line.angleString(angle)); LOG.debug(msg); ldrVertex.property("steer",angle); ldrVertex.property("steerBy",navigateRange.name); ldrVertex.property("debugInfo",msg); tsLatestCommand = currentTime; message = steerCommand(angle); } return message; } StraightLaneNavigator(); StraightLaneNavigator(int timeWindow); DukesVerticle getSender(); void setSender(DukesVerticle sender); Vertex addToGraph(LaneDetectionResult ldr); @Override LaneDetectionResult fromJsonObject(JsonObject jo); boolean cmdOk(AngleRange angleRange, int minFound); void setTime(LaneDetectionResult ldr); void analyzeAngleRanges(int timeWindow, boolean showDebug); @Override JsonObject getNavigationInstruction(LaneDetectionResult ldr); JsonObject steerCommand(Double angle); @Override void navigateWithInstruction(JsonObject navigationInstruction); @Override void navigateWithMessage(Message<JsonObject> ldrMessage); @Override void navigateWithLaneDetectionResult(LaneDetectionResult ldr); @Override void videoStopped(VideoInfo videoInfo); }
StraightLaneNavigator extends TinkerPopDatabase implements Navigator { @Override public JsonObject getNavigationInstruction(LaneDetectionResult ldr) { JsonObject message = null; if (this.emergencyStopActivated) return message; setTime(ldr); Vertex ldrVertex=addToGraph(ldr); boolean showDebug = true; analyzeAngleRanges(timeWindow, showDebug); if (currentTime - startTime > MAX_DURATION_NO_LINES_DETECTED && stopRangeLeft.count + stopRangeRight.count == 0 || emergencyStopActivated) { this.emergencyStopActivated = true; return ActionVerticle.emergencyStopCommand(); } int MIN_FOUND_PER_TIMEWINDOW = 3; AngleRange navigateRange = null; if (middleRange.count >= MIN_FOUND_PER_TIMEWINDOW) { navigateRange = courseRange; } else { navigateRange = leftRange.count > rightRange.count ? leftRange : rightRange; } if (this.cmdOk(navigateRange, MIN_FOUND_PER_TIMEWINDOW)) { double angle = navigateRange.steer(); String msg = ldr.debugInfo() + String.format("\nsteer by %s: %s", navigateRange.name, Line.angleString(angle)); LOG.debug(msg); ldrVertex.property("steer",angle); ldrVertex.property("steerBy",navigateRange.name); ldrVertex.property("debugInfo",msg); tsLatestCommand = currentTime; message = steerCommand(angle); } return message; } StraightLaneNavigator(); StraightLaneNavigator(int timeWindow); DukesVerticle getSender(); void setSender(DukesVerticle sender); Vertex addToGraph(LaneDetectionResult ldr); @Override LaneDetectionResult fromJsonObject(JsonObject jo); boolean cmdOk(AngleRange angleRange, int minFound); void setTime(LaneDetectionResult ldr); void analyzeAngleRanges(int timeWindow, boolean showDebug); @Override JsonObject getNavigationInstruction(LaneDetectionResult ldr); JsonObject steerCommand(Double angle); @Override void navigateWithInstruction(JsonObject navigationInstruction); @Override void navigateWithMessage(Message<JsonObject> ldrMessage); @Override void navigateWithLaneDetectionResult(LaneDetectionResult ldr); @Override void videoStopped(VideoInfo videoInfo); static int COMMAND_LOOP_INTERVAL; static final int MAX_DURATION_NO_LINES_DETECTED; static final int DEFAULT_TIME_WINDOW; }
@Test public void testWatchDog() throws Exception { ClusterStarter clusterStarter=new ClusterStarter(); Car car=TestCar.getCar(); Environment env = Config.getEnvironment(); int heartBeatInterval=env.getInteger(Config.WATCHDOG_HEARTBEAT_INTERVAL_MS); assertEquals(20,heartBeatInterval); int maxMissedBeats=env.getInteger(Config.WATCHDOG_MAX_MISSED_BEATS); assertEquals(2,maxMissedBeats); WatchDog watchDog=new WatchDog(car); clusterStarter.deployVerticles(watchDog); watchDog.waitStatus(Status.started,20000,10); Vertx vertx=clusterStarter.getVertx(); assertNotNull(vertx); assertEquals(watchDog.getVertx(),vertx); watchDog.send(Characters.FLASH,"type","heartbeat"); int loops=0; while(!car.powerIsOn() && loops<=100) { Thread.sleep(10); loops++; } assertTrue(loops<100); LOG.info(String.format("car powered on after %3d msecs",loops*10)); Thread.sleep(heartBeatInterval*(maxMissedBeats+3)); assertTrue(!car.powerIsOn()); }
public WatchDog(Car car) throws Exception { super(Characters.FLASH); this.car = car; Environment env = Config.getEnvironment(); HEARTBEAT_INTERVAL_MS=env.getInteger(Config.WATCHDOG_HEARTBEAT_INTERVAL_MS); MAX_MISSED_BEATS=env.getInteger(Config.WATCHDOG_MAX_MISSED_BEATS); }
WatchDog extends DukesVerticle { public WatchDog(Car car) throws Exception { super(Characters.FLASH); this.car = car; Environment env = Config.getEnvironment(); HEARTBEAT_INTERVAL_MS=env.getInteger(Config.WATCHDOG_HEARTBEAT_INTERVAL_MS); MAX_MISSED_BEATS=env.getInteger(Config.WATCHDOG_MAX_MISSED_BEATS); } }
WatchDog extends DukesVerticle { public WatchDog(Car car) throws Exception { super(Characters.FLASH); this.car = car; Environment env = Config.getEnvironment(); HEARTBEAT_INTERVAL_MS=env.getInteger(Config.WATCHDOG_HEARTBEAT_INTERVAL_MS); MAX_MISSED_BEATS=env.getInteger(Config.WATCHDOG_MAX_MISSED_BEATS); } WatchDog(Car car); }
WatchDog extends DukesVerticle { public WatchDog(Car car) throws Exception { super(Characters.FLASH); this.car = car; Environment env = Config.getEnvironment(); HEARTBEAT_INTERVAL_MS=env.getInteger(Config.WATCHDOG_HEARTBEAT_INTERVAL_MS); MAX_MISSED_BEATS=env.getInteger(Config.WATCHDOG_MAX_MISSED_BEATS); } WatchDog(Car car); @Override void start(); }
WatchDog extends DukesVerticle { public WatchDog(Car car) throws Exception { super(Characters.FLASH); this.car = car; Environment env = Config.getEnvironment(); HEARTBEAT_INTERVAL_MS=env.getInteger(Config.WATCHDOG_HEARTBEAT_INTERVAL_MS); MAX_MISSED_BEATS=env.getInteger(Config.WATCHDOG_MAX_MISSED_BEATS); } WatchDog(Car car); @Override void start(); }
@Test public void testSteering() throws Exception { Car car = getCar(); Steering steering = car.getSteering(); steering.center(); ServoPosition cpos = steering.getSteeringMap().getCurrentPosition(); System.out.println(cpos); }
public Steering getSteering() { return steering; }
Car { public Steering getSteering() { return steering; } }
Car { public Steering getSteering() { return steering; } private Car(); }
Car { public Steering getSteering() { return steering; } private Car(); void configure(Engine engine, Steering steering, Led led); void setPowerOn(); void setPowerOff(); boolean powerIsOn(); void stop(); void turn(ServoPosition position); void drive(ServoPosition speed); Engine getEngine(); Steering getSteering(); Led getLed(); static Car getInstance(); static void resetInstance(); }
Car { public Steering getSteering() { return steering; } private Car(); void configure(Engine engine, Steering steering, Led led); void setPowerOn(); void setPowerOff(); boolean powerIsOn(); void stop(); void turn(ServoPosition position); void drive(ServoPosition speed); Engine getEngine(); Steering getSteering(); Led getLed(); static Car getInstance(); static void resetInstance(); static ServoCommand servoCommand; }
@Test public void testLed() throws Exception { Car car = getCar(); Led led = car.getLed(); led.statusLedOn(); led.statusLedOff(); if (debug) servoCommand.showLog(); }
public Led getLed() { return led; }
Car { public Led getLed() { return led; } }
Car { public Led getLed() { return led; } private Car(); }
Car { public Led getLed() { return led; } private Car(); void configure(Engine engine, Steering steering, Led led); void setPowerOn(); void setPowerOff(); boolean powerIsOn(); void stop(); void turn(ServoPosition position); void drive(ServoPosition speed); Engine getEngine(); Steering getSteering(); Led getLed(); static Car getInstance(); static void resetInstance(); }
Car { public Led getLed() { return led; } private Car(); void configure(Engine engine, Steering steering, Led led); void setPowerOn(); void setPowerOff(); boolean powerIsOn(); void stop(); void turn(ServoPosition position); void drive(ServoPosition speed); Engine getEngine(); Steering getSteering(); Led getLed(); static Car getInstance(); static void resetInstance(); static ServoCommand servoCommand; }
@Test public void testImageFetcher() { ImageFetcher imageFetcher = getTestImageFetcher(); imageFetcher.debug=debug; Image image; do { image= imageFetcher.fetch(); } while (image != null); if (debug) { String msg = String.format("%s has %d frames", testSource, imageFetcher.getFrameIndex()); System.out.println(msg); } assertEquals(488, imageFetcher.getFrameIndex()); }
public ImageFetcher(String source) { this.source = source; }
ImageFetcher { public ImageFetcher(String source) { this.source = source; } }
ImageFetcher { public ImageFetcher(String source) { this.source = source; } ImageFetcher(String source); }
ImageFetcher { public ImageFetcher(String source) { this.source = source; } ImageFetcher(String source); double getFps(); void setFps(double fps); int getFrameIndex(); boolean isStaticImage(); void setStaticImage(boolean staticImage); boolean open(); void close(); long waitForNextFrame(); Image fetch(); Image createNextImage(Mat frame, long currentMillis); Observable<Image> toObservable(); boolean hasNext(); boolean isClosed(); }
ImageFetcher { public ImageFetcher(String source) { this.source = source; } ImageFetcher(String source); double getFps(); void setFps(double fps); int getFrameIndex(); boolean isStaticImage(); void setStaticImage(boolean staticImage); boolean open(); void close(); long waitForNextFrame(); Image fetch(); Image createNextImage(Mat frame, long currentMillis); Observable<Image> toObservable(); boolean hasNext(); boolean isClosed(); public boolean debug; static double DEFAULT_FPS; }
@Test public void testImageFetcherObservable() { ImageFetcher imageFetcher = getTestImageFetcher(); Observable<Image> imageObservable = imageFetcher.toObservable(); ImageObserver imageObserver = new ImageObserver(); imageObserver.debug=debug; imageObservable.subscribe(imageObserver); assertNull(imageObserver.error); assertTrue(imageObserver.completed); assertEquals(768,imageObserver.cols); assertEquals(576,imageObserver.rows); }
public Observable<Image> toObservable() { Observable<Image> observable = Observable .create(new ObservableOnSubscribe<Image>() { @Override public void subscribe(ObservableEmitter<Image> observableEmitter) throws Exception { hasNext=true; while (hasNext && !isClosed()) { final Image image = ImageFetcher.this.fetch(); if (hasNext) { if (debug && frameIndex % Math.round(getFps()) == 0) { String msg = String.format("->%6d:%4.0fx%4.0f", frameIndex, size.width, size.height); LOG.info(msg); } observableEmitter.onNext(image); } } observableEmitter.onComplete(); } }); return observable; }
ImageFetcher { public Observable<Image> toObservable() { Observable<Image> observable = Observable .create(new ObservableOnSubscribe<Image>() { @Override public void subscribe(ObservableEmitter<Image> observableEmitter) throws Exception { hasNext=true; while (hasNext && !isClosed()) { final Image image = ImageFetcher.this.fetch(); if (hasNext) { if (debug && frameIndex % Math.round(getFps()) == 0) { String msg = String.format("->%6d:%4.0fx%4.0f", frameIndex, size.width, size.height); LOG.info(msg); } observableEmitter.onNext(image); } } observableEmitter.onComplete(); } }); return observable; } }
ImageFetcher { public Observable<Image> toObservable() { Observable<Image> observable = Observable .create(new ObservableOnSubscribe<Image>() { @Override public void subscribe(ObservableEmitter<Image> observableEmitter) throws Exception { hasNext=true; while (hasNext && !isClosed()) { final Image image = ImageFetcher.this.fetch(); if (hasNext) { if (debug && frameIndex % Math.round(getFps()) == 0) { String msg = String.format("->%6d:%4.0fx%4.0f", frameIndex, size.width, size.height); LOG.info(msg); } observableEmitter.onNext(image); } } observableEmitter.onComplete(); } }); return observable; } ImageFetcher(String source); }
ImageFetcher { public Observable<Image> toObservable() { Observable<Image> observable = Observable .create(new ObservableOnSubscribe<Image>() { @Override public void subscribe(ObservableEmitter<Image> observableEmitter) throws Exception { hasNext=true; while (hasNext && !isClosed()) { final Image image = ImageFetcher.this.fetch(); if (hasNext) { if (debug && frameIndex % Math.round(getFps()) == 0) { String msg = String.format("->%6d:%4.0fx%4.0f", frameIndex, size.width, size.height); LOG.info(msg); } observableEmitter.onNext(image); } } observableEmitter.onComplete(); } }); return observable; } ImageFetcher(String source); double getFps(); void setFps(double fps); int getFrameIndex(); boolean isStaticImage(); void setStaticImage(boolean staticImage); boolean open(); void close(); long waitForNextFrame(); Image fetch(); Image createNextImage(Mat frame, long currentMillis); Observable<Image> toObservable(); boolean hasNext(); boolean isClosed(); }
ImageFetcher { public Observable<Image> toObservable() { Observable<Image> observable = Observable .create(new ObservableOnSubscribe<Image>() { @Override public void subscribe(ObservableEmitter<Image> observableEmitter) throws Exception { hasNext=true; while (hasNext && !isClosed()) { final Image image = ImageFetcher.this.fetch(); if (hasNext) { if (debug && frameIndex % Math.round(getFps()) == 0) { String msg = String.format("->%6d:%4.0fx%4.0f", frameIndex, size.width, size.height); LOG.info(msg); } observableEmitter.onNext(image); } } observableEmitter.onComplete(); } }); return observable; } ImageFetcher(String source); double getFps(); void setFps(double fps); int getFrameIndex(); boolean isStaticImage(); void setStaticImage(boolean staticImage); boolean open(); void close(); long waitForNextFrame(); Image fetch(); Image createNextImage(Mat frame, long currentMillis); Observable<Image> toObservable(); boolean hasNext(); boolean isClosed(); public boolean debug; static double DEFAULT_FPS; }
@Test public void testImageFetcherObservableSample() { ImageFetcher imageFetcher = getTestImageFetcher(); Observable<Image> imageObservable = imageFetcher.toObservable(); ImageObserver imageObserver = new ImageObserver(); imageObserver.debug=debug; imageObservable.sample(40, TimeUnit.MILLISECONDS).subscribe(imageObserver); assertNull(imageObserver.error); assertTrue(imageObserver.completed); assertEquals(768,imageObserver.cols); assertEquals(576,imageObserver.rows); }
public Observable<Image> toObservable() { Observable<Image> observable = Observable .create(new ObservableOnSubscribe<Image>() { @Override public void subscribe(ObservableEmitter<Image> observableEmitter) throws Exception { hasNext=true; while (hasNext && !isClosed()) { final Image image = ImageFetcher.this.fetch(); if (hasNext) { if (debug && frameIndex % Math.round(getFps()) == 0) { String msg = String.format("->%6d:%4.0fx%4.0f", frameIndex, size.width, size.height); LOG.info(msg); } observableEmitter.onNext(image); } } observableEmitter.onComplete(); } }); return observable; }
ImageFetcher { public Observable<Image> toObservable() { Observable<Image> observable = Observable .create(new ObservableOnSubscribe<Image>() { @Override public void subscribe(ObservableEmitter<Image> observableEmitter) throws Exception { hasNext=true; while (hasNext && !isClosed()) { final Image image = ImageFetcher.this.fetch(); if (hasNext) { if (debug && frameIndex % Math.round(getFps()) == 0) { String msg = String.format("->%6d:%4.0fx%4.0f", frameIndex, size.width, size.height); LOG.info(msg); } observableEmitter.onNext(image); } } observableEmitter.onComplete(); } }); return observable; } }
ImageFetcher { public Observable<Image> toObservable() { Observable<Image> observable = Observable .create(new ObservableOnSubscribe<Image>() { @Override public void subscribe(ObservableEmitter<Image> observableEmitter) throws Exception { hasNext=true; while (hasNext && !isClosed()) { final Image image = ImageFetcher.this.fetch(); if (hasNext) { if (debug && frameIndex % Math.round(getFps()) == 0) { String msg = String.format("->%6d:%4.0fx%4.0f", frameIndex, size.width, size.height); LOG.info(msg); } observableEmitter.onNext(image); } } observableEmitter.onComplete(); } }); return observable; } ImageFetcher(String source); }
ImageFetcher { public Observable<Image> toObservable() { Observable<Image> observable = Observable .create(new ObservableOnSubscribe<Image>() { @Override public void subscribe(ObservableEmitter<Image> observableEmitter) throws Exception { hasNext=true; while (hasNext && !isClosed()) { final Image image = ImageFetcher.this.fetch(); if (hasNext) { if (debug && frameIndex % Math.round(getFps()) == 0) { String msg = String.format("->%6d:%4.0fx%4.0f", frameIndex, size.width, size.height); LOG.info(msg); } observableEmitter.onNext(image); } } observableEmitter.onComplete(); } }); return observable; } ImageFetcher(String source); double getFps(); void setFps(double fps); int getFrameIndex(); boolean isStaticImage(); void setStaticImage(boolean staticImage); boolean open(); void close(); long waitForNextFrame(); Image fetch(); Image createNextImage(Mat frame, long currentMillis); Observable<Image> toObservable(); boolean hasNext(); boolean isClosed(); }
ImageFetcher { public Observable<Image> toObservable() { Observable<Image> observable = Observable .create(new ObservableOnSubscribe<Image>() { @Override public void subscribe(ObservableEmitter<Image> observableEmitter) throws Exception { hasNext=true; while (hasNext && !isClosed()) { final Image image = ImageFetcher.this.fetch(); if (hasNext) { if (debug && frameIndex % Math.round(getFps()) == 0) { String msg = String.format("->%6d:%4.0fx%4.0f", frameIndex, size.width, size.height); LOG.info(msg); } observableEmitter.onNext(image); } } observableEmitter.onComplete(); } }); return observable; } ImageFetcher(String source); double getFps(); void setFps(double fps); int getFrameIndex(); boolean isStaticImage(); void setStaticImage(boolean staticImage); boolean open(); void close(); long waitForNextFrame(); Image fetch(); Image createNextImage(Mat frame, long currentMillis); Observable<Image> toObservable(); boolean hasNext(); boolean isClosed(); public boolean debug; static double DEFAULT_FPS; }
@Test public void testRemoteCar() throws Exception { Environment.mock(); ClusterStarter clusterStarter = new ClusterStarter(); clusterStarter.prepare(); RemoteCar remoteCar = new RemoteCar(); clusterStarter.deployVerticles(remoteCar); DukesVerticle.debug=true; remoteCar.waitStatus(Status.started, ClusterStarter.MAX_START_TIME, 10); JsonObject configJo=Config.getEnvironment().asJsonObject(); remoteCar.send(Characters.GENERAL_LEE,configJo); Thread.sleep(ClusterStarter.MAX_START_TIME); }
public RemoteCar() { super(Characters.GENERAL_LEE); }
RemoteCar extends DukesVerticle { public RemoteCar() { super(Characters.GENERAL_LEE); } }
RemoteCar extends DukesVerticle { public RemoteCar() { super(Characters.GENERAL_LEE); } RemoteCar(); }
RemoteCar extends DukesVerticle { public RemoteCar() { super(Characters.GENERAL_LEE); } RemoteCar(); @Override void start(); void parseArguments(String[] args); void mainInstance(String... args); static void main(String... args); }
RemoteCar extends DukesVerticle { public RemoteCar() { super(Characters.GENERAL_LEE); } RemoteCar(); @Override void start(); void parseArguments(String[] args); void mainInstance(String... args); static void main(String... args); @Option(name = "-ph", aliases = { "--publichost" }, usage = "hostname") String publicHost; }
@Test public void testRemoteCarCommandLine() { Environment.mock(); String args[]= {}; RemoteCar.main(args); }
public static void main(String... args) { RemoteCar remoteCar = new RemoteCar(); remoteCar.mainInstance(args); }
RemoteCar extends DukesVerticle { public static void main(String... args) { RemoteCar remoteCar = new RemoteCar(); remoteCar.mainInstance(args); } }
RemoteCar extends DukesVerticle { public static void main(String... args) { RemoteCar remoteCar = new RemoteCar(); remoteCar.mainInstance(args); } RemoteCar(); }
RemoteCar extends DukesVerticle { public static void main(String... args) { RemoteCar remoteCar = new RemoteCar(); remoteCar.mainInstance(args); } RemoteCar(); @Override void start(); void parseArguments(String[] args); void mainInstance(String... args); static void main(String... args); }
RemoteCar extends DukesVerticle { public static void main(String... args) { RemoteCar remoteCar = new RemoteCar(); remoteCar.mainInstance(args); } RemoteCar(); @Override void start(); void parseArguments(String[] args); void mainInstance(String... args); static void main(String... args); @Option(name = "-ph", aliases = { "--publichost" }, usage = "hostname") String publicHost; }
@Test public void testChessboard() { CameraMatrix matrix = new CameraMatrix(7, 7); Mat chessboard = Imgcodecs.imread(testPath + "dukes_chessBoard008.png"); Point[] corners = matrix.findOuterChessBoardCornerPoints(chessboard); assertNotNull(corners); assertEquals(4, corners.length); if (debug) { System.out.print("corners: "); String delim = ""; for (int i = 0; i < 4; i++) { System.out.print( String.format("(%.1f,%.1f)%s", corners[i].x, corners[i].y, delim)); delim = ","; if (i == 2) delim = "\n"; } } writeImage("chessBoardCorners", chessboard); Size size = chessboard.size(); Polygon imagePolygon = new ImagePolygon(size, 0, 0, 1, 0, 1, 1, 0, 1); Polygon worldPolygon = new ImagePolygon(corners); PerspectiveShift perspectiveShift = new PerspectiveShift(imagePolygon, worldPolygon); if (debug) { System.out.println("image: " + perspectiveShift.imagePoints); System.out.println("world: " + perspectiveShift.worldPoints); } Mat shifted = perspectiveShift.apply(chessboard); writeImage("shiftedChessBoard", shifted); }
@Override public Mat apply(Mat srcImage) { Mat destImage = new Mat(); Imgproc.warpPerspective(srcImage, destImage, perspectiveTransform, srcImage.size()); return destImage; }
PerspectiveShift implements UnaryOperator<Mat> { @Override public Mat apply(Mat srcImage) { Mat destImage = new Mat(); Imgproc.warpPerspective(srcImage, destImage, perspectiveTransform, srcImage.size()); return destImage; } }
PerspectiveShift implements UnaryOperator<Mat> { @Override public Mat apply(Mat srcImage) { Mat destImage = new Mat(); Imgproc.warpPerspective(srcImage, destImage, perspectiveTransform, srcImage.size()); return destImage; } PerspectiveShift(Polygon imagePolygon, Polygon worldPolygon); }
PerspectiveShift implements UnaryOperator<Mat> { @Override public Mat apply(Mat srcImage) { Mat destImage = new Mat(); Imgproc.warpPerspective(srcImage, destImage, perspectiveTransform, srcImage.size()); return destImage; } PerspectiveShift(Polygon imagePolygon, Polygon worldPolygon); @Override Mat apply(Mat srcImage); }
PerspectiveShift implements UnaryOperator<Mat> { @Override public Mat apply(Mat srcImage) { Mat destImage = new Mat(); Imgproc.warpPerspective(srcImage, destImage, perspectiveTransform, srcImage.size()); return destImage; } PerspectiveShift(Polygon imagePolygon, Polygon worldPolygon); @Override Mat apply(Mat srcImage); }
@Test public void testTransform() throws Exception { Mat original = Imgcodecs.imread(testPath + "dukes_livingroom.jpeg"); ROI roi = new ROI("near", 0, 0.4, 1, 0.6); Mat image = roi.region(original); Polygon imagePolygon = new ImagePolygon(image.size(), 0, 0, 1, 0, 1, 1, 0, 1); Polygon worldPolygon = new ImagePolygon(image.size(), 0.30, 0.20, 0.80, 0.28, 0.96, 0.62, 0.15, 0.46); PerspectiveShift perspectiveShift = new PerspectiveShift(imagePolygon, worldPolygon); Mat shifted = perspectiveShift.apply(image); if (debug) { System.out.println("worldp:" + perspectiveShift.worldPolygon); System.out.println("world: " + perspectiveShift.worldPoints); writeImage("roiImage", image); writeImage("shiftedImage", shifted); } }
@Override public Mat apply(Mat srcImage) { Mat destImage = new Mat(); Imgproc.warpPerspective(srcImage, destImage, perspectiveTransform, srcImage.size()); return destImage; }
PerspectiveShift implements UnaryOperator<Mat> { @Override public Mat apply(Mat srcImage) { Mat destImage = new Mat(); Imgproc.warpPerspective(srcImage, destImage, perspectiveTransform, srcImage.size()); return destImage; } }
PerspectiveShift implements UnaryOperator<Mat> { @Override public Mat apply(Mat srcImage) { Mat destImage = new Mat(); Imgproc.warpPerspective(srcImage, destImage, perspectiveTransform, srcImage.size()); return destImage; } PerspectiveShift(Polygon imagePolygon, Polygon worldPolygon); }
PerspectiveShift implements UnaryOperator<Mat> { @Override public Mat apply(Mat srcImage) { Mat destImage = new Mat(); Imgproc.warpPerspective(srcImage, destImage, perspectiveTransform, srcImage.size()); return destImage; } PerspectiveShift(Polygon imagePolygon, Polygon worldPolygon); @Override Mat apply(Mat srcImage); }
PerspectiveShift implements UnaryOperator<Mat> { @Override public Mat apply(Mat srcImage) { Mat destImage = new Mat(); Imgproc.warpPerspective(srcImage, destImage, perspectiveTransform, srcImage.size()); return destImage; } PerspectiveShift(Polygon imagePolygon, Polygon worldPolygon); @Override Mat apply(Mat srcImage); }
@Test public void fromExponents() throws Exception { RSAKeyPair rsaPair = RSAKeyPair.fromExponents(rsaSpec.e, rsaSpec.p, rsaSpec.q); assertArrayEquals(rsaPair.n, rsaSpec.n); assertArrayEquals(rsaPair.e, rsaSpec.e); assertArrayEquals(rsaPair.d, rsaSpec.d); assertArrayEquals(rsaPair.p, rsaSpec.p); assertArrayEquals(rsaPair.q, rsaSpec.q); assertArrayEquals(rsaPair.dP, rsaSpec.dP); assertArrayEquals(rsaPair.dQ, rsaSpec.dQ); assertArrayEquals(rsaPair.qInv, rsaSpec.qInv); }
public static RSAKeyPair fromExponents(byte[] e, byte[] p, byte[] q) { final BigInteger eInt = BigIntegers.fromUnsignedByteArray(e), pInt = BigIntegers.fromUnsignedByteArray(p), qInt = BigIntegers.fromUnsignedByteArray(q), nInt = pInt.multiply(qInt), mInt = pInt.subtract(BigInteger.ONE).multiply(qInt.subtract(BigInteger.ONE)), dInt = eInt.modInverse(mInt), dPInt = dInt.remainder(pInt.subtract(BigInteger.ONE)), dQInt = dInt.remainder(qInt.subtract(BigInteger.ONE)), qInvInt = qInt.modInverse(pInt); final byte[] n = BigIntegers.asUnsignedByteArray(nInt), d = BigIntegers.asUnsignedByteArray(dInt), dP = BigIntegers.asUnsignedByteArray(dPInt), dQ = BigIntegers.asUnsignedByteArray(dQInt), qInv = BigIntegers.asUnsignedByteArray(qInvInt); return new RSAKeyPair(n, e, d, p, q, dP, dQ, qInv); }
RSAKeyPair { public static RSAKeyPair fromExponents(byte[] e, byte[] p, byte[] q) { final BigInteger eInt = BigIntegers.fromUnsignedByteArray(e), pInt = BigIntegers.fromUnsignedByteArray(p), qInt = BigIntegers.fromUnsignedByteArray(q), nInt = pInt.multiply(qInt), mInt = pInt.subtract(BigInteger.ONE).multiply(qInt.subtract(BigInteger.ONE)), dInt = eInt.modInverse(mInt), dPInt = dInt.remainder(pInt.subtract(BigInteger.ONE)), dQInt = dInt.remainder(qInt.subtract(BigInteger.ONE)), qInvInt = qInt.modInverse(pInt); final byte[] n = BigIntegers.asUnsignedByteArray(nInt), d = BigIntegers.asUnsignedByteArray(dInt), dP = BigIntegers.asUnsignedByteArray(dPInt), dQ = BigIntegers.asUnsignedByteArray(dQInt), qInv = BigIntegers.asUnsignedByteArray(qInvInt); return new RSAKeyPair(n, e, d, p, q, dP, dQ, qInv); } }
RSAKeyPair { public static RSAKeyPair fromExponents(byte[] e, byte[] p, byte[] q) { final BigInteger eInt = BigIntegers.fromUnsignedByteArray(e), pInt = BigIntegers.fromUnsignedByteArray(p), qInt = BigIntegers.fromUnsignedByteArray(q), nInt = pInt.multiply(qInt), mInt = pInt.subtract(BigInteger.ONE).multiply(qInt.subtract(BigInteger.ONE)), dInt = eInt.modInverse(mInt), dPInt = dInt.remainder(pInt.subtract(BigInteger.ONE)), dQInt = dInt.remainder(qInt.subtract(BigInteger.ONE)), qInvInt = qInt.modInverse(pInt); final byte[] n = BigIntegers.asUnsignedByteArray(nInt), d = BigIntegers.asUnsignedByteArray(dInt), dP = BigIntegers.asUnsignedByteArray(dPInt), dQ = BigIntegers.asUnsignedByteArray(dQInt), qInv = BigIntegers.asUnsignedByteArray(qInvInt); return new RSAKeyPair(n, e, d, p, q, dP, dQ, qInv); } RSAKeyPair(byte[] n, byte[] e, byte[] d, byte[] p, byte[] q, byte[] dP, byte[] dQ, byte[] qInv); }
RSAKeyPair { public static RSAKeyPair fromExponents(byte[] e, byte[] p, byte[] q) { final BigInteger eInt = BigIntegers.fromUnsignedByteArray(e), pInt = BigIntegers.fromUnsignedByteArray(p), qInt = BigIntegers.fromUnsignedByteArray(q), nInt = pInt.multiply(qInt), mInt = pInt.subtract(BigInteger.ONE).multiply(qInt.subtract(BigInteger.ONE)), dInt = eInt.modInverse(mInt), dPInt = dInt.remainder(pInt.subtract(BigInteger.ONE)), dQInt = dInt.remainder(qInt.subtract(BigInteger.ONE)), qInvInt = qInt.modInverse(pInt); final byte[] n = BigIntegers.asUnsignedByteArray(nInt), d = BigIntegers.asUnsignedByteArray(dInt), dP = BigIntegers.asUnsignedByteArray(dPInt), dQ = BigIntegers.asUnsignedByteArray(dQInt), qInv = BigIntegers.asUnsignedByteArray(qInvInt); return new RSAKeyPair(n, e, d, p, q, dP, dQ, qInv); } RSAKeyPair(byte[] n, byte[] e, byte[] d, byte[] p, byte[] q, byte[] dP, byte[] dQ, byte[] qInv); static RSAKeyPair fromExponents(byte[] e, byte[] p, byte[] q); }
RSAKeyPair { public static RSAKeyPair fromExponents(byte[] e, byte[] p, byte[] q) { final BigInteger eInt = BigIntegers.fromUnsignedByteArray(e), pInt = BigIntegers.fromUnsignedByteArray(p), qInt = BigIntegers.fromUnsignedByteArray(q), nInt = pInt.multiply(qInt), mInt = pInt.subtract(BigInteger.ONE).multiply(qInt.subtract(BigInteger.ONE)), dInt = eInt.modInverse(mInt), dPInt = dInt.remainder(pInt.subtract(BigInteger.ONE)), dQInt = dInt.remainder(qInt.subtract(BigInteger.ONE)), qInvInt = qInt.modInverse(pInt); final byte[] n = BigIntegers.asUnsignedByteArray(nInt), d = BigIntegers.asUnsignedByteArray(dInt), dP = BigIntegers.asUnsignedByteArray(dPInt), dQ = BigIntegers.asUnsignedByteArray(dQInt), qInv = BigIntegers.asUnsignedByteArray(qInvInt); return new RSAKeyPair(n, e, d, p, q, dP, dQ, qInv); } RSAKeyPair(byte[] n, byte[] e, byte[] d, byte[] p, byte[] q, byte[] dP, byte[] dQ, byte[] qInv); static RSAKeyPair fromExponents(byte[] e, byte[] p, byte[] q); final byte[] n; final byte[] e; final byte[] d; final byte[] p; final byte[] q; final byte[] dP; final byte[] dQ; final byte[] qInv; }
@Test public void checkLimitRequestsForKey() throws Exception { PrivateKey myKey = TestKeys.privateKey(3); List<Main> mm = new ArrayList<>(); for (int i = 0; i < 4; i++) mm.add(createMain("node" + (i + 1), false)); mm.forEach(x -> x.config.setIsFreeRegistrationsAllowedFromYaml(true)); Main main = mm.get(0); Client client = null; try { client = new Client(myKey, main.myInfo, null); } catch (Exception e) { System.out.println("prepareClient exception: " + e.toString()); } for (int i = 0; i < main.config.getLimitRequestsForKeyPerMinute() * 2; i++) { Contract testContract = new Contract(myKey); testContract.seal(); assertTrue(testContract.isOk()); Set<PublicKey> ownerKeys = new HashSet(); Collection<PrivateKey> keys = Do.listOf(myKey); keys.stream().forEach(key -> ownerKeys.add(key.getPublicKey())); Contract stepaU = InnerContractsService.createFreshU(100000000, ownerKeys); stepaU.check(); stepaU.traceErrors(); client.register(stepaU.getPackedTransaction()); Set<PrivateKey> keySet = new HashSet<>(); keySet.addAll(keys); Parcel parcel = ContractsService.createParcel(testContract, stepaU, 150, keySet); client.registerParcel(parcel.pack()); } long seconds = ZonedDateTime.now().toEpochSecond() % 60; if (seconds > 57) Thread.currentThread().sleep(3000); for (int i = 0; i < main.config.getLimitRequestsForKeyPerMinute(); i++) System.out.println(">> storage rate: " + client.storageGetRate()); String exception = ""; try { client.storageGetRate(); } catch (Exception e) { System.out.println("Client exception: " + e.toString()); exception = e.getMessage(); } assertEquals(exception, "ClientError: COMMAND_FAILED exceeded the limit of requests for key per minute," + " please call again after a while"); System.out.println("Wait 1 munite..."); Thread.currentThread().sleep(60000); seconds = ZonedDateTime.now().toEpochSecond() % 60; if (seconds > 57) Thread.currentThread().sleep(3000); for (int i = 0; i < main.config.getLimitRequestsForKeyPerMinute(); i++) System.out.println(">> uns rate: " + client.unsRate()); exception = ""; try { client.unsRate(); } catch (Exception e) { System.out.println("Client exception: " + e.toString()); exception = e.getMessage(); } assertEquals(exception, "ClientError: COMMAND_FAILED exceeded the limit of requests for key per minute," + " please call again after a while"); System.out.println("Wait 1 munite..."); Thread.currentThread().sleep(60000); seconds = ZonedDateTime.now().toEpochSecond() % 60; if (seconds > 57) Thread.currentThread().sleep(3000); for (int i = 0; i < main.config.getLimitRequestsForKeyPerMinute(); i++) client.getStats(90); exception = ""; try { client.getStats(90); } catch (Exception e) { System.out.println("Client exception: " + e.toString()); exception = e.getMessage(); } assertEquals(exception, "ClientError: COMMAND_FAILED exceeded the limit of requests for key per minute," + " please call again after a while"); mm.forEach(x -> x.shutdown()); }
public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); static final String NODE_VERSION; final Reporter reporter; final BufferedLogger logger; public NetConfig netConfig; public NetworkV2 network; final Config config; public NodeInfo myInfo; public Node node; public ItemCache cache; public ParcelCache parcelCache; public PaidOperationCache paidOperationCache; }
@Test public void checkUnlimitRequestsForKey() throws Exception { PrivateKey myKey = TestKeys.privateKey(3); List<Main> mm = new ArrayList<>(); for (int i = 0; i < 4; i++) mm.add(createMain("node" + (i + 1), false)); mm.forEach(x -> x.config.setIsFreeRegistrationsAllowedFromYaml(true)); Main main = mm.get(0); Client client = null; try { client = new Client(myKey, main.myInfo, null); } catch (Exception e) { System.out.println("prepareClient exception: " + e.toString()); } Set<PublicKey> ownerKeys = new HashSet(); Set<PrivateKey> keys = new HashSet(); keys.add(myKey); ownerKeys.add(myKey.getPublicKey()); Contract payment = InnerContractsService.createFreshU(100000000, ownerKeys); payment.check(); payment.traceErrors(); client.register(payment.getPackedTransaction()); Thread.currentThread().sleep(5000); mm.forEach(x -> x.config.setIsFreeRegistrationsAllowedFromYaml(false)); long seconds = ZonedDateTime.now().toEpochSecond() % 60; if (seconds > 57) Thread.currentThread().sleep(3000); for (int i = 0; i < main.config.getLimitRequestsForKeyPerMinute(); i++) System.out.println(">> storage rate: " + client.storageGetRate()); String exception = ""; try { client.storageGetRate(); } catch (Exception e) { System.out.println("Client exception: " + e.toString()); exception = e.getMessage(); } assertEquals(exception, "ClientError: COMMAND_FAILED exceeded the limit of requests for key per minute," + " please call again after a while"); Contract unlimitContract = ContractsService.createRateLimitDisablingContract( myKey.getPublicKey(), payment, main.config.getRateLimitDisablingPayment(), keys); unlimitContract.check(); unlimitContract.traceErrors(); assertTrue(unlimitContract.isOk()); ItemResult itemResult = client.register(unlimitContract.getPackedTransaction()); Thread.currentThread().sleep(5000); itemResult = client.getState(unlimitContract.getId()); System.out.println(">> state: " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); for (int i = 0; i < main.config.getLimitRequestsForKeyPerMinute() * 2; i++) System.out.println(">> storage rate: " + client.storageGetRate()); for (int i = 0; i < main.config.getLimitRequestsForKeyPerMinute() * 2; i++) System.out.println(">> uns rate: " + client.unsRate()); for (int i = 0; i < main.config.getLimitRequestsForKeyPerMinute() * 2; i++) client.getStats(90); mm.forEach(x -> x.shutdown()); }
public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); static final String NODE_VERSION; final Reporter reporter; final BufferedLogger logger; public NetConfig netConfig; public NetworkV2 network; final Config config; public NodeInfo myInfo; public Node node; public ItemCache cache; public ParcelCache parcelCache; public PaidOperationCache paidOperationCache; }
@Test public void checkUnlimitRequestsBadParam() throws Exception { PrivateKey myKey = TestKeys.privateKey(3); List<Main> mm = new ArrayList<>(); for (int i = 0; i < 4; i++) mm.add(createMain("node" + (i + 1), false)); mm.forEach(x -> x.config.setIsFreeRegistrationsAllowedFromYaml(true)); Main main = mm.get(0); Client client = null; try { client = new Client(myKey, main.myInfo, null); } catch (Exception e) { System.out.println("prepareClient exception: " + e.toString()); } Set<PublicKey> ownerKeys = new HashSet(); Set<PrivateKey> keys = new HashSet(); keys.add(myKey); ownerKeys.add(myKey.getPublicKey()); Contract payment = InnerContractsService.createFreshU(100000000, ownerKeys); payment.check(); payment.traceErrors(); client.register(payment.getPackedTransaction()); Thread.currentThread().sleep(5000); mm.forEach(x -> x.config.setIsFreeRegistrationsAllowedFromYaml(false)); Contract unlimitContract = ContractsService.createRateLimitDisablingContract( myKey.getPublicKey(), payment, 1, keys); Contract unlimitContract1 = ContractsService.createRateLimitDisablingContract( myKey.getPublicKey(), payment, main.config.getRateLimitDisablingPayment() + 1, keys); unlimitContract.check(); unlimitContract.traceErrors(); assertTrue(unlimitContract.isOk()); unlimitContract1.check(); unlimitContract1.traceErrors(); assertTrue(unlimitContract1.isOk()); System.out.println("Processing cost " + unlimitContract.getProcessedCostU()); ItemResult itemResult = client.register(unlimitContract.getPackedTransaction()); Thread.currentThread().sleep(5000); System.out.println(); assertEquals((itemResult.errors.get(0).getMessage()), "Payment for setting unlimited requests" + " must be 5U"); itemResult = client.getState(unlimitContract.getId()); System.out.println(">> state: " + itemResult); assertEquals(ItemState.UNDEFINED, itemResult.state); itemResult = client.register(unlimitContract1.getPackedTransaction()); Thread.currentThread().sleep(5000); System.out.println(); assertEquals((itemResult.errors.get(0).getMessage()), "Payment for setting unlimited requests" + " must be 5U"); itemResult = client.getState(unlimitContract1.getId()); System.out.println(">> state: " + itemResult); assertEquals(ItemState.UNDEFINED, itemResult.state); mm.forEach(x -> x.shutdown()); }
public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); static final String NODE_VERSION; final Reporter reporter; final BufferedLogger logger; public NetConfig netConfig; public NetworkV2 network; final Config config; public NodeInfo myInfo; public Node node; public ItemCache cache; public ParcelCache parcelCache; public PaidOperationCache paidOperationCache; }
@Test public void checkUnlimitRequestsBadKey() throws Exception { PrivateKey myKey = TestKeys.privateKey(3); List<Main> mm = new ArrayList<>(); for (int i = 0; i < 4; i++) mm.add(createMain("node" + (i + 1), false)); mm.forEach(x -> x.config.setIsFreeRegistrationsAllowedFromYaml(true)); Main main = mm.get(0); Client client = null; try { client = new Client(myKey, main.myInfo, null); } catch (Exception e) { System.out.println("prepareClient exception: " + e.toString()); } Set<PublicKey> ownerKeys = new HashSet(); Set<PrivateKey> keys = new HashSet(); keys.add(myKey); ownerKeys.add(myKey.getPublicKey()); Contract payment = InnerContractsService.createFreshU(100, ownerKeys); payment.check(); payment.traceErrors(); client.register(payment.getPackedTransaction()); Thread.currentThread().sleep(5000); mm.forEach(x -> x.config.setIsFreeRegistrationsAllowedFromYaml(false)); Contract unlimitContract = ContractsService.createRateLimitDisablingContract( myKey.getPublicKey(), payment, main.config.getRateLimitDisablingPayment(), keys); byte[] packedKey = unlimitContract.getTransactional().getData().getBinary("unlimited_key"); PublicKey key = new PublicKey(packedKey); assertFalse((packedKey == null) || ((key == null))); assertEquals(unlimitContract.getRevoking().get(0).getStateData().getIntOrThrow("transaction_units") - unlimitContract.getStateData().getIntOrThrow("transaction_units"), 5); unlimitContract.check(); unlimitContract.traceErrors(); assertTrue(unlimitContract.isOk()); unlimitContract.getTransactional().getData().set("unlimited_key", "badkeybadkeybadkeybadkey"); unlimitContract.seal(); client.register(unlimitContract.getPackedTransaction()); Thread.currentThread().sleep(5000); System.out.println(); ItemResult itemResult = client.getState(unlimitContract.getId()); System.out.println(">> state: " + itemResult); assertEquals(ItemState.UNDEFINED, itemResult.state); mm.forEach(x -> x.shutdown()); }
public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); static final String NODE_VERSION; final Reporter reporter; final BufferedLogger logger; public NetConfig netConfig; public NetworkV2 network; final Config config; public NodeInfo myInfo; public Node node; public ItemCache cache; public ParcelCache parcelCache; public PaidOperationCache paidOperationCache; }
@Test public void checkLimitRequestsTestU() throws Exception { PrivateKey myKey = TestKeys.privateKey(3); List<Main> mm = new ArrayList<>(); for (int i = 0; i < 4; i++) mm.add(createMain("node" + (i + 1), false)); mm.forEach(x -> x.config.setIsFreeRegistrationsAllowedFromYaml(true)); Main main = mm.get(0); Client client = null; try { client = new Client(myKey, main.myInfo, null); } catch (Exception e) { System.out.println("prepareClient exception: " + e.toString()); } Set<PublicKey> ownerKeys = new HashSet(); Set<PrivateKey> keys = new HashSet(); keys.add(myKey); ownerKeys.add(myKey.getPublicKey()); Contract payment = InnerContractsService.createFreshU(100, ownerKeys, true); payment.check(); payment.traceErrors(); client.register(payment.getPackedTransaction()); Thread.currentThread().sleep(5000); ItemResult itemResult = client.getState(payment.getId()); System.out.println(">> state payment: " + itemResult); System.out.println(payment.getStateData().getString("transaction_units")); assertEquals(ItemState.APPROVED, itemResult.state); payment = payment.createRevision(myKey); payment.getStateData().set("transaction_units", 0); payment.setOwnerKeys(ownerKeys); payment.addSignerKey(myKey); payment.seal(); client.register(payment.getPackedTransaction()); Thread.currentThread().sleep(5000); itemResult = client.getState(payment.getId()); System.out.println(">> state payment: " + itemResult); System.out.println(payment.getStateData().getString("transaction_units")); assertEquals(ItemState.APPROVED, itemResult.state); mm.forEach(x -> x.config.setIsFreeRegistrationsAllowedFromYaml(false)); Contract unlimitContract = ContractsService.createRateLimitDisablingContract( myKey.getPublicKey(), payment, main.config.getRateLimitDisablingPayment(), keys); client.register(unlimitContract.getPackedTransaction()); Thread.currentThread().sleep(5000); itemResult = client.getState(unlimitContract.getId()); System.out.println(">> state: " + itemResult); assertEquals(ItemState.DECLINED, itemResult.state); mm.forEach(x -> x.shutdown()); }
public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); static final String NODE_VERSION; final Reporter reporter; final BufferedLogger logger; public NetConfig netConfig; public NetworkV2 network; final Config config; public NodeInfo myInfo; public Node node; public ItemCache cache; public ParcelCache parcelCache; public PaidOperationCache paidOperationCache; }
@Test public void ecsrowComplete() throws Exception { List<Main> mm = new ArrayList<>(); for (int i = 0; i < 4; i++) mm.add(createMain("node" + (i + 1), false)); Main main = mm.get(0); main.config.setIsFreeRegistrationsAllowedFromYaml(true); Client client = new Client(TestKeys.privateKey(20), main.myInfo, null); Set<PrivateKey> issuerPrivateKeys = new HashSet<>(asList(TestKeys.privateKey(0))); Set<PrivateKey> customerPrivateKeys = new HashSet<>(asList(TestKeys.privateKey(1))); Set<PrivateKey> arbitratorPrivateKeys = new HashSet<>(asList(TestKeys.privateKey(2))); Set<PrivateKey> executorPrivateKeys = new HashSet<>(asList(TestKeys.privateKey(3))); Set<PublicKey> issuerPublicKeys = new HashSet<>(); for (PrivateKey pk : issuerPrivateKeys) { issuerPublicKeys.add(pk.getPublicKey()); } Set<PublicKey> customerPublicKeys = new HashSet<>(); for (PrivateKey pk : customerPrivateKeys) { customerPublicKeys.add(pk.getPublicKey()); } Set<PublicKey> executorPublicKeys = new HashSet<>(); for (PrivateKey pk : executorPrivateKeys) { executorPublicKeys.add(pk.getPublicKey()); } Set<PublicKey> arbitratorPublicKeys = new HashSet<>(); for (PrivateKey pk : arbitratorPrivateKeys) { arbitratorPublicKeys.add(pk.getPublicKey()); } Contract payment = InnerContractsService.createFreshU(100, customerPublicKeys, true); payment.check(); payment.traceErrors(); ItemResult itemResult = client.register(payment.getPackedTransaction(), 5000); System.out.println("payment : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); payment = payment.createRevision(customerPrivateKeys); Contract escrow = ContractsService.createEscrowContract(issuerPrivateKeys, customerPublicKeys, executorPublicKeys, arbitratorPublicKeys); assertEquals(escrow.getDefinition().getData().getString("EscrowOrigin", "null"), escrow.getNew().get(0).getOrigin().toBase64String()); assertEquals(escrow.getNew().get(0).getStateData().getString("status", "null"), "opened"); boolean result = ContractsService.addPaymentToEscrowContract(escrow, payment, customerPrivateKeys, customerPublicKeys, executorPublicKeys); assertTrue(result); assertTrue(payment.findReferenceByName("return_payment_to_customer", "transactional") != null); assertTrue(payment.findReferenceByName("send_payment_to_executor", "transactional") != null); escrow.check(); escrow.traceErrors(); itemResult = client.register(escrow.getPackedTransaction(), 5000); System.out.println("escrow : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); itemResult = main.node.waitItem(payment.getId(), 8000); assertEquals(ItemState.APPROVED, itemResult.state); Contract completedEscrow = ContractsService.completeEscrowContract(escrow); assertEquals(completedEscrow.getStateData().getString("status", "null"), "completed"); completedEscrow.addSignatureToSeal(issuerPrivateKeys); completedEscrow = Contract.fromPackedTransaction(completedEscrow.getPackedTransaction()); completedEscrow.addSignatureToSeal(customerPrivateKeys); completedEscrow = Contract.fromPackedTransaction(completedEscrow.getPackedTransaction()); completedEscrow.addSignatureToSeal(executorPrivateKeys); completedEscrow.check(); completedEscrow.traceErrors(); itemResult = client.register(completedEscrow.getPackedTransaction(), 5000); System.out.println("completedEscrow : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); Contract newPayment = ContractsService.takeEscrowPayment(executorPrivateKeys, payment); newPayment.getTransactionPack().addReferencedItem(completedEscrow); newPayment.check(); newPayment.traceErrors(); itemResult = client.register(newPayment.getPackedTransaction(), 5000); System.out.println("newPayment : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); mm.forEach(x -> x.shutdown()); }
public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); static final String NODE_VERSION; final Reporter reporter; final BufferedLogger logger; public NetConfig netConfig; public NetworkV2 network; final Config config; public NodeInfo myInfo; public Node node; public ItemCache cache; public ParcelCache parcelCache; public PaidOperationCache paidOperationCache; }
@Test public void ecsrowCancel() throws Exception { List<Main> mm = new ArrayList<>(); for (int i = 0; i < 4; i++) mm.add(createMain("node" + (i + 1), false)); Main main = mm.get(0); main.config.setIsFreeRegistrationsAllowedFromYaml(true); Client client = new Client(TestKeys.privateKey(20), main.myInfo, null); Set<PrivateKey> issuerPrivateKeys = new HashSet<>(asList(TestKeys.privateKey(0))); Set<PrivateKey> customerPrivateKeys = new HashSet<>(asList(TestKeys.privateKey(1))); Set<PrivateKey> arbitratorPrivateKeys = new HashSet<>(asList(TestKeys.privateKey(2))); Set<PrivateKey> executorPrivateKeys = new HashSet<>(asList(TestKeys.privateKey(3))); Set<PublicKey> issuerPublicKeys = new HashSet<>(); for (PrivateKey pk : issuerPrivateKeys) { issuerPublicKeys.add(pk.getPublicKey()); } Set<PublicKey> customerPublicKeys = new HashSet<>(); for (PrivateKey pk : customerPrivateKeys) { customerPublicKeys.add(pk.getPublicKey()); } Set<PublicKey> executorPublicKeys = new HashSet<>(); for (PrivateKey pk : executorPrivateKeys) { executorPublicKeys.add(pk.getPublicKey()); } Set<PublicKey> arbitratorPublicKeys = new HashSet<>(); for (PrivateKey pk : arbitratorPrivateKeys) { arbitratorPublicKeys.add(pk.getPublicKey()); } Contract payment = InnerContractsService.createFreshU(100, customerPublicKeys, true); payment.check(); payment.traceErrors(); ItemResult itemResult = client.register(payment.getPackedTransaction(), 5000); System.out.println("payment : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); payment = payment.createRevision(customerPrivateKeys); Contract escrow = ContractsService.createEscrowContract(issuerPrivateKeys, customerPublicKeys, executorPublicKeys, arbitratorPublicKeys); assertEquals(escrow.getDefinition().getData().getString("EscrowOrigin", "null"), escrow.getNew().get(0).getOrigin().toBase64String()); assertEquals(escrow.getNew().get(0).getStateData().getString("status", "null"), "opened"); boolean result = ContractsService.addPaymentToEscrowContract(escrow, payment, customerPrivateKeys, customerPublicKeys, executorPublicKeys); assertTrue(result); assertTrue(payment.findReferenceByName("return_payment_to_customer", "transactional") != null); assertTrue(payment.findReferenceByName("send_payment_to_executor", "transactional") != null); escrow.check(); escrow.traceErrors(); itemResult = client.register(escrow.getPackedTransaction(), 5000); System.out.println("escrow : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); itemResult = main.node.waitItem(payment.getId(), 8000); assertEquals(ItemState.APPROVED, itemResult.state); Contract canceledEscrow = ContractsService.cancelEscrowContract(escrow); assertEquals(canceledEscrow.getStateData().getString("status", "null"), "canceled"); canceledEscrow.addSignatureToSeal(issuerPrivateKeys); canceledEscrow = Contract.fromPackedTransaction(canceledEscrow.getPackedTransaction()); canceledEscrow.addSignatureToSeal(customerPrivateKeys); canceledEscrow = Contract.fromPackedTransaction(canceledEscrow.getPackedTransaction()); canceledEscrow.addSignatureToSeal(arbitratorPrivateKeys); canceledEscrow.check(); canceledEscrow.traceErrors(); itemResult = client.register(canceledEscrow.getPackedTransaction(), 5000); System.out.println("canceledEscrow : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); Contract newPayment = ContractsService.takeEscrowPayment(customerPrivateKeys, payment); newPayment.getTransactionPack().addReferencedItem(canceledEscrow); newPayment.check(); newPayment.traceErrors(); itemResult = client.register(newPayment.getPackedTransaction(), 5000); System.out.println("newPayment: " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); mm.forEach(x -> x.shutdown()); }
public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); static final String NODE_VERSION; final Reporter reporter; final BufferedLogger logger; public NetConfig netConfig; public NetworkV2 network; final Config config; public NodeInfo myInfo; public Node node; public ItemCache cache; public ParcelCache parcelCache; public PaidOperationCache paidOperationCache; }
@Test public void ecsrowCompleteFail() throws Exception { List<Main> mm = new ArrayList<>(); for (int i = 0; i < 4; i++) mm.add(createMain("node" + (i + 1), false)); Main main = mm.get(0); main.config.setIsFreeRegistrationsAllowedFromYaml(true); Client client = new Client(TestKeys.privateKey(20), main.myInfo, null); Set<PrivateKey> issuerPrivateKeys = new HashSet<>(asList(TestKeys.privateKey(0))); Set<PrivateKey> customerPrivateKeys = new HashSet<>(asList(TestKeys.privateKey(1))); Set<PrivateKey> arbitratorPrivateKeys = new HashSet<>(asList(TestKeys.privateKey(2))); Set<PrivateKey> executorPrivateKeys = new HashSet<>(asList(TestKeys.privateKey(3))); Set<PublicKey> issuerPublicKeys = new HashSet<>(); for (PrivateKey pk : issuerPrivateKeys) { issuerPublicKeys.add(pk.getPublicKey()); } Set<PublicKey> customerPublicKeys = new HashSet<>(); for (PrivateKey pk : customerPrivateKeys) { customerPublicKeys.add(pk.getPublicKey()); } Set<PublicKey> executorPublicKeys = new HashSet<>(); for (PrivateKey pk : executorPrivateKeys) { executorPublicKeys.add(pk.getPublicKey()); } Set<PublicKey> arbitratorPublicKeys = new HashSet<>(); for (PrivateKey pk : arbitratorPrivateKeys) { arbitratorPublicKeys.add(pk.getPublicKey()); } Contract payment = InnerContractsService.createFreshU(100, customerPublicKeys, true); payment.check(); payment.traceErrors(); ItemResult itemResult = client.register(payment.getPackedTransaction(), 5000); System.out.println("payment : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); payment = payment.createRevision(customerPrivateKeys); Contract escrow = ContractsService.createEscrowContract(issuerPrivateKeys, customerPublicKeys, executorPublicKeys, arbitratorPublicKeys); assertEquals(escrow.getDefinition().getData().getString("EscrowOrigin", "null"), escrow.getNew().get(0).getOrigin().toBase64String()); assertEquals(escrow.getNew().get(0).getStateData().getString("status", "null"), "opened"); boolean result = ContractsService.addPaymentToEscrowContract(escrow, payment, customerPrivateKeys, customerPublicKeys, executorPublicKeys); assertTrue(result); assertTrue(payment.findReferenceByName("return_payment_to_customer", "transactional") != null); assertTrue(payment.findReferenceByName("send_payment_to_executor", "transactional") != null); escrow.check(); escrow.traceErrors(); itemResult = client.register(escrow.getPackedTransaction(), 5000); System.out.println("escrow : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); itemResult = main.node.waitItem(payment.getId(), 8000); assertEquals(ItemState.APPROVED, itemResult.state); Contract completedEscrow = ContractsService.completeEscrowContract(escrow); assertEquals(completedEscrow.getStateData().getString("status", "null"), "completed"); completedEscrow.addSignatureToSeal(issuerPrivateKeys); completedEscrow = Contract.fromPackedTransaction(completedEscrow.getPackedTransaction()); completedEscrow.addSignatureToSeal(executorPrivateKeys); completedEscrow.check(); completedEscrow.traceErrors(); itemResult = client.register(completedEscrow.getPackedTransaction(), 5000); System.out.println("completedEscrow : " + itemResult); assertEquals(ItemState.DECLINED, itemResult.state); Contract newPayment = ContractsService.takeEscrowPayment(executorPrivateKeys, payment); newPayment.getTransactionPack().addReferencedItem(completedEscrow); newPayment.check(); newPayment.traceErrors(); itemResult = client.register(newPayment.getPackedTransaction(), 5000); System.out.println("newPayment : " + itemResult); assertEquals(ItemState.DECLINED, itemResult.state); mm.forEach(x -> x.shutdown()); }
public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); static final String NODE_VERSION; final Reporter reporter; final BufferedLogger logger; public NetConfig netConfig; public NetworkV2 network; final Config config; public NodeInfo myInfo; public Node node; public ItemCache cache; public ParcelCache parcelCache; public PaidOperationCache paidOperationCache; }
@Test public void ecsrowCancelFail() throws Exception { List<Main> mm = new ArrayList<>(); for (int i = 0; i < 4; i++) mm.add(createMain("node" + (i + 1), false)); Main main = mm.get(0); main.config.setIsFreeRegistrationsAllowedFromYaml(true); Client client = new Client(TestKeys.privateKey(20), main.myInfo, null); Set<PrivateKey> issuerPrivateKeys = new HashSet<>(asList(TestKeys.privateKey(0))); Set<PrivateKey> customerPrivateKeys = new HashSet<>(asList(TestKeys.privateKey(1))); Set<PrivateKey> arbitratorPrivateKeys = new HashSet<>(asList(TestKeys.privateKey(2))); Set<PrivateKey> executorPrivateKeys = new HashSet<>(asList(TestKeys.privateKey(3))); Set<PublicKey> issuerPublicKeys = new HashSet<>(); for (PrivateKey pk : issuerPrivateKeys) { issuerPublicKeys.add(pk.getPublicKey()); } Set<PublicKey> customerPublicKeys = new HashSet<>(); for (PrivateKey pk : customerPrivateKeys) { customerPublicKeys.add(pk.getPublicKey()); } Set<PublicKey> executorPublicKeys = new HashSet<>(); for (PrivateKey pk : executorPrivateKeys) { executorPublicKeys.add(pk.getPublicKey()); } Set<PublicKey> arbitratorPublicKeys = new HashSet<>(); for (PrivateKey pk : arbitratorPrivateKeys) { arbitratorPublicKeys.add(pk.getPublicKey()); } Contract payment = InnerContractsService.createFreshU(100, customerPublicKeys, true); payment.check(); payment.traceErrors(); ItemResult itemResult = client.register(payment.getPackedTransaction(), 5000); System.out.println("payment : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); payment = payment.createRevision(customerPrivateKeys); Contract escrow = ContractsService.createEscrowContract(issuerPrivateKeys, customerPublicKeys, executorPublicKeys, arbitratorPublicKeys); assertEquals(escrow.getDefinition().getData().getString("EscrowOrigin", "null"), escrow.getNew().get(0).getOrigin().toBase64String()); assertEquals(escrow.getNew().get(0).getStateData().getString("status", "null"), "opened"); boolean result = ContractsService.addPaymentToEscrowContract(escrow, payment, customerPrivateKeys, customerPublicKeys, executorPublicKeys); assertTrue(result); assertTrue(payment.findReferenceByName("return_payment_to_customer", "transactional") != null); assertTrue(payment.findReferenceByName("send_payment_to_executor", "transactional") != null); escrow.check(); escrow.traceErrors(); itemResult = client.register(escrow.getPackedTransaction(), 5000); System.out.println("escrow : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); itemResult = main.node.waitItem(payment.getId(), 8000); assertEquals(ItemState.APPROVED, itemResult.state); Contract canceledEscrow = ContractsService.cancelEscrowContract(escrow); assertEquals(canceledEscrow.getStateData().getString("status", "null"), "canceled"); canceledEscrow.addSignatureToSeal(issuerPrivateKeys); canceledEscrow = Contract.fromPackedTransaction(canceledEscrow.getPackedTransaction()); canceledEscrow.addSignatureToSeal(customerPrivateKeys); canceledEscrow.check(); canceledEscrow.traceErrors(); itemResult = client.register(canceledEscrow.getPackedTransaction(), 5000); System.out.println("canceledEscrow : " + itemResult); assertEquals(ItemState.DECLINED, itemResult.state); Contract newPayment = ContractsService.takeEscrowPayment(customerPrivateKeys, payment); newPayment.getTransactionPack().addReferencedItem(canceledEscrow); newPayment.check(); newPayment.traceErrors(); itemResult = client.register(newPayment.getPackedTransaction(), 5000); System.out.println("newPayment : " + itemResult); assertEquals(ItemState.DECLINED, itemResult.state); mm.forEach(x -> x.shutdown()); }
public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); static final String NODE_VERSION; final Reporter reporter; final BufferedLogger logger; public NetConfig netConfig; public NetworkV2 network; final Config config; public NodeInfo myInfo; public Node node; public ItemCache cache; public ParcelCache parcelCache; public PaidOperationCache paidOperationCache; }
@Test public void ecsrowCompleteAndTakePaymentFail() throws Exception { List<Main> mm = new ArrayList<>(); for (int i = 0; i < 4; i++) mm.add(createMain("node" + (i + 1), false)); Main main = mm.get(0); main.config.setIsFreeRegistrationsAllowedFromYaml(true); Client client = new Client(TestKeys.privateKey(20), main.myInfo, null); Set<PrivateKey> issuerPrivateKeys = new HashSet<>(asList(TestKeys.privateKey(0))); Set<PrivateKey> customerPrivateKeys = new HashSet<>(asList(TestKeys.privateKey(1))); Set<PrivateKey> arbitratorPrivateKeys = new HashSet<>(asList(TestKeys.privateKey(2))); Set<PrivateKey> executorPrivateKeys = new HashSet<>(asList(TestKeys.privateKey(3))); Set<PublicKey> issuerPublicKeys = new HashSet<>(); for (PrivateKey pk : issuerPrivateKeys) { issuerPublicKeys.add(pk.getPublicKey()); } Set<PublicKey> customerPublicKeys = new HashSet<>(); for (PrivateKey pk : customerPrivateKeys) { customerPublicKeys.add(pk.getPublicKey()); } Set<PublicKey> executorPublicKeys = new HashSet<>(); for (PrivateKey pk : executorPrivateKeys) { executorPublicKeys.add(pk.getPublicKey()); } Set<PublicKey> arbitratorPublicKeys = new HashSet<>(); for (PrivateKey pk : arbitratorPrivateKeys) { arbitratorPublicKeys.add(pk.getPublicKey()); } Contract payment = InnerContractsService.createFreshU(100, customerPublicKeys, true); payment.check(); payment.traceErrors(); ItemResult itemResult = client.register(payment.getPackedTransaction(), 5000); System.out.println("payment : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); payment = payment.createRevision(customerPrivateKeys); Contract escrow = ContractsService.createEscrowContract(issuerPrivateKeys, customerPublicKeys, executorPublicKeys, arbitratorPublicKeys); assertEquals(escrow.getDefinition().getData().getString("EscrowOrigin", "null"), escrow.getNew().get(0).getOrigin().toBase64String()); assertEquals(escrow.getNew().get(0).getStateData().getString("status", "null"), "opened"); boolean result = ContractsService.addPaymentToEscrowContract(escrow, payment, customerPrivateKeys, customerPublicKeys, executorPublicKeys); assertTrue(result); assertTrue(payment.findReferenceByName("return_payment_to_customer", "transactional") != null); assertTrue(payment.findReferenceByName("send_payment_to_executor", "transactional") != null); escrow.check(); escrow.traceErrors(); itemResult = client.register(escrow.getPackedTransaction(), 5000); System.out.println("escrow : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); itemResult = main.node.waitItem(payment.getId(), 8000); assertEquals(ItemState.APPROVED, itemResult.state); Contract completedEscrow = ContractsService.completeEscrowContract(escrow); assertEquals(completedEscrow.getStateData().getString("status", "null"), "completed"); completedEscrow.addSignatureToSeal(issuerPrivateKeys); completedEscrow = Contract.fromPackedTransaction(completedEscrow.getPackedTransaction()); completedEscrow.addSignatureToSeal(customerPrivateKeys); completedEscrow = Contract.fromPackedTransaction(completedEscrow.getPackedTransaction()); completedEscrow.addSignatureToSeal(executorPrivateKeys); completedEscrow.check(); completedEscrow.traceErrors(); itemResult = client.register(completedEscrow.getPackedTransaction(), 5000); System.out.println("completedEscrow : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); Contract newPayment = ContractsService.takeEscrowPayment(customerPrivateKeys, payment); newPayment.getTransactionPack().addReferencedItem(completedEscrow); newPayment.check(); newPayment.traceErrors(); itemResult = client.register(newPayment.getPackedTransaction(), 5000); System.out.println("newPayment : " + itemResult); assertEquals(ItemState.DECLINED, itemResult.state); mm.forEach(x -> x.shutdown()); }
public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); static final String NODE_VERSION; final Reporter reporter; final BufferedLogger logger; public NetConfig netConfig; public NetworkV2 network; final Config config; public NodeInfo myInfo; public Node node; public ItemCache cache; public ParcelCache parcelCache; public PaidOperationCache paidOperationCache; }
@Test public void checkSignature() throws Exception { AbstractPublicKey rsaPublicKey = pssSpec.getPublicKey(); AbstractPrivateKey rsaPrivateKey = pssSpec.getPrivateKey(); assertArrayEquals( rsaPrivateKey.sign(pssSpec.M, HashType.SHA1, RSASSAPSSTestVectors.salt), pssSpec.S); assertTrue(rsaPublicKey.checkSignature( pssSpec.M, rsaPrivateKey.sign(pssSpec.M, HashType.SHA1, RSASSAPSSTestVectors.salt), HashType.SHA1, RSASSAPSSTestVectors.salt.length)); }
@NonNull @Override public boolean checkSignature(InputStream input, byte[] signature, HashType hashType, int saltLength) throws IllegalStateException, IOException { if (state == null) { throw new IllegalStateException(); } else { final Digest primaryDigest = hashType.makeDigest(); if (saltLength == MAX_SALT_LENGTH) { saltLength = getMaxSaltLength(getBitStrength(), primaryDigest.getDigestSize()); } if (saltLength < 0) { throw new RuntimeException(String.format("Incorrect salt length %s", saltLength)); } final Signer signatureChecker = new PSSSigner( RSAEngineFactory.make(), primaryDigest, state.mgf1HashType.makeDigest(), saltLength); signatureChecker.init(false, new ParametersWithRandom(state.keyParameters, state.rng)); boolean done = false; while (!done) { int availableBytes = input.available(); if (availableBytes <= 0) { done = true; } else { byte[] buffer = new byte[availableBytes]; int howManyBytesRead = input.read(buffer); if (howManyBytesRead <= 0) { done = true; } else { signatureChecker.update(buffer, 0, howManyBytesRead); } } } return signatureChecker.verifySignature(signature); } }
RSAOAEPPublicKey extends AbstractPublicKey { @NonNull @Override public boolean checkSignature(InputStream input, byte[] signature, HashType hashType, int saltLength) throws IllegalStateException, IOException { if (state == null) { throw new IllegalStateException(); } else { final Digest primaryDigest = hashType.makeDigest(); if (saltLength == MAX_SALT_LENGTH) { saltLength = getMaxSaltLength(getBitStrength(), primaryDigest.getDigestSize()); } if (saltLength < 0) { throw new RuntimeException(String.format("Incorrect salt length %s", saltLength)); } final Signer signatureChecker = new PSSSigner( RSAEngineFactory.make(), primaryDigest, state.mgf1HashType.makeDigest(), saltLength); signatureChecker.init(false, new ParametersWithRandom(state.keyParameters, state.rng)); boolean done = false; while (!done) { int availableBytes = input.available(); if (availableBytes <= 0) { done = true; } else { byte[] buffer = new byte[availableBytes]; int howManyBytesRead = input.read(buffer); if (howManyBytesRead <= 0) { done = true; } else { signatureChecker.update(buffer, 0, howManyBytesRead); } } } return signatureChecker.verifySignature(signature); } } }
RSAOAEPPublicKey extends AbstractPublicKey { @NonNull @Override public boolean checkSignature(InputStream input, byte[] signature, HashType hashType, int saltLength) throws IllegalStateException, IOException { if (state == null) { throw new IllegalStateException(); } else { final Digest primaryDigest = hashType.makeDigest(); if (saltLength == MAX_SALT_LENGTH) { saltLength = getMaxSaltLength(getBitStrength(), primaryDigest.getDigestSize()); } if (saltLength < 0) { throw new RuntimeException(String.format("Incorrect salt length %s", saltLength)); } final Signer signatureChecker = new PSSSigner( RSAEngineFactory.make(), primaryDigest, state.mgf1HashType.makeDigest(), saltLength); signatureChecker.init(false, new ParametersWithRandom(state.keyParameters, state.rng)); boolean done = false; while (!done) { int availableBytes = input.available(); if (availableBytes <= 0) { done = true; } else { byte[] buffer = new byte[availableBytes]; int howManyBytesRead = input.read(buffer); if (howManyBytesRead <= 0) { done = true; } else { signatureChecker.update(buffer, 0, howManyBytesRead); } } } return signatureChecker.verifySignature(signature); } } RSAOAEPPublicKey(); RSAOAEPPublicKey(byte[] n, byte[] e, HashType oaepHashType, HashType mgf1HashType, SecureRandom rng); }
RSAOAEPPublicKey extends AbstractPublicKey { @NonNull @Override public boolean checkSignature(InputStream input, byte[] signature, HashType hashType, int saltLength) throws IllegalStateException, IOException { if (state == null) { throw new IllegalStateException(); } else { final Digest primaryDigest = hashType.makeDigest(); if (saltLength == MAX_SALT_LENGTH) { saltLength = getMaxSaltLength(getBitStrength(), primaryDigest.getDigestSize()); } if (saltLength < 0) { throw new RuntimeException(String.format("Incorrect salt length %s", saltLength)); } final Signer signatureChecker = new PSSSigner( RSAEngineFactory.make(), primaryDigest, state.mgf1HashType.makeDigest(), saltLength); signatureChecker.init(false, new ParametersWithRandom(state.keyParameters, state.rng)); boolean done = false; while (!done) { int availableBytes = input.available(); if (availableBytes <= 0) { done = true; } else { byte[] buffer = new byte[availableBytes]; int howManyBytesRead = input.read(buffer); if (howManyBytesRead <= 0) { done = true; } else { signatureChecker.update(buffer, 0, howManyBytesRead); } } } return signatureChecker.verifySignature(signature); } } RSAOAEPPublicKey(); RSAOAEPPublicKey(byte[] n, byte[] e, HashType oaepHashType, HashType mgf1HashType, SecureRandom rng); @Override String toString(); @Override boolean canEncrypt(); @Override int getBitStrength(); @Override boolean isInitialized(); @NonNull @Override byte[] encrypt(byte[] plaintext); @NonNull @Override boolean checkSignature(InputStream input, byte[] signature, HashType hashType, int saltLength); @NonNull @Override String algorithmTag(); @NonNull @Override Map<String, Object> toHash(); @Override void updateFromHash(Map<String, Object> hash); }
RSAOAEPPublicKey extends AbstractPublicKey { @NonNull @Override public boolean checkSignature(InputStream input, byte[] signature, HashType hashType, int saltLength) throws IllegalStateException, IOException { if (state == null) { throw new IllegalStateException(); } else { final Digest primaryDigest = hashType.makeDigest(); if (saltLength == MAX_SALT_LENGTH) { saltLength = getMaxSaltLength(getBitStrength(), primaryDigest.getDigestSize()); } if (saltLength < 0) { throw new RuntimeException(String.format("Incorrect salt length %s", saltLength)); } final Signer signatureChecker = new PSSSigner( RSAEngineFactory.make(), primaryDigest, state.mgf1HashType.makeDigest(), saltLength); signatureChecker.init(false, new ParametersWithRandom(state.keyParameters, state.rng)); boolean done = false; while (!done) { int availableBytes = input.available(); if (availableBytes <= 0) { done = true; } else { byte[] buffer = new byte[availableBytes]; int howManyBytesRead = input.read(buffer); if (howManyBytesRead <= 0) { done = true; } else { signatureChecker.update(buffer, 0, howManyBytesRead); } } } return signatureChecker.verifySignature(signature); } } RSAOAEPPublicKey(); RSAOAEPPublicKey(byte[] n, byte[] e, HashType oaepHashType, HashType mgf1HashType, SecureRandom rng); @Override String toString(); @Override boolean canEncrypt(); @Override int getBitStrength(); @Override boolean isInitialized(); @NonNull @Override byte[] encrypt(byte[] plaintext); @NonNull @Override boolean checkSignature(InputStream input, byte[] signature, HashType hashType, int saltLength); @NonNull @Override String algorithmTag(); @NonNull @Override Map<String, Object> toHash(); @Override void updateFromHash(Map<String, Object> hash); static final HashType DEFAULT_OAEP_HASH; static final HashType DEFAULT_MGF1_HASH; }
@Test public void ecsrowCancelAndTakePaymentFail() throws Exception { List<Main> mm = new ArrayList<>(); for (int i = 0; i < 4; i++) mm.add(createMain("node" + (i + 1), false)); Main main = mm.get(0); main.config.setIsFreeRegistrationsAllowedFromYaml(true); Client client = new Client(TestKeys.privateKey(20), main.myInfo, null); Set<PrivateKey> issuerPrivateKeys = new HashSet<>(asList(TestKeys.privateKey(0))); Set<PrivateKey> customerPrivateKeys = new HashSet<>(asList(TestKeys.privateKey(1))); Set<PrivateKey> arbitratorPrivateKeys = new HashSet<>(asList(TestKeys.privateKey(2))); Set<PrivateKey> executorPrivateKeys = new HashSet<>(asList(TestKeys.privateKey(3))); Set<PublicKey> issuerPublicKeys = new HashSet<>(); for (PrivateKey pk : issuerPrivateKeys) { issuerPublicKeys.add(pk.getPublicKey()); } Set<PublicKey> customerPublicKeys = new HashSet<>(); for (PrivateKey pk : customerPrivateKeys) { customerPublicKeys.add(pk.getPublicKey()); } Set<PublicKey> executorPublicKeys = new HashSet<>(); for (PrivateKey pk : executorPrivateKeys) { executorPublicKeys.add(pk.getPublicKey()); } Set<PublicKey> arbitratorPublicKeys = new HashSet<>(); for (PrivateKey pk : arbitratorPrivateKeys) { arbitratorPublicKeys.add(pk.getPublicKey()); } Contract payment = InnerContractsService.createFreshU(100, customerPublicKeys, true); payment.check(); payment.traceErrors(); ItemResult itemResult = client.register(payment.getPackedTransaction(), 5000); System.out.println("payment : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); payment = payment.createRevision(customerPrivateKeys); Contract escrow = ContractsService.createEscrowContract(issuerPrivateKeys, customerPublicKeys, executorPublicKeys, arbitratorPublicKeys); assertEquals(escrow.getDefinition().getData().getString("EscrowOrigin", "null"), escrow.getNew().get(0).getOrigin().toBase64String()); assertEquals(escrow.getNew().get(0).getStateData().getString("status", "null"), "opened"); boolean result = ContractsService.addPaymentToEscrowContract(escrow, payment, customerPrivateKeys, customerPublicKeys, executorPublicKeys); assertTrue(result); assertTrue(payment.findReferenceByName("return_payment_to_customer", "transactional") != null); assertTrue(payment.findReferenceByName("send_payment_to_executor", "transactional") != null); escrow.check(); escrow.traceErrors(); itemResult = client.register(escrow.getPackedTransaction(), 5000); System.out.println("escrow : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); itemResult = main.node.waitItem(payment.getId(), 8000); assertEquals(ItemState.APPROVED, itemResult.state); Contract canceledEscrow = ContractsService.cancelEscrowContract(escrow); assertEquals(canceledEscrow.getStateData().getString("status", "null"), "canceled"); canceledEscrow.addSignatureToSeal(issuerPrivateKeys); canceledEscrow = Contract.fromPackedTransaction(canceledEscrow.getPackedTransaction()); canceledEscrow.addSignatureToSeal(customerPrivateKeys); canceledEscrow = Contract.fromPackedTransaction(canceledEscrow.getPackedTransaction()); canceledEscrow.addSignatureToSeal(arbitratorPrivateKeys); canceledEscrow.check(); canceledEscrow.traceErrors(); itemResult = client.register(canceledEscrow.getPackedTransaction(), 5000); System.out.println("canceledEscrow : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); Contract newPayment = ContractsService.takeEscrowPayment(executorPrivateKeys, payment); newPayment.getTransactionPack().addReferencedItem(canceledEscrow); newPayment.check(); newPayment.traceErrors(); itemResult = client.register(newPayment.getPackedTransaction(), 5000); System.out.println("newPayment : " + itemResult); assertEquals(ItemState.DECLINED, itemResult.state); mm.forEach(x -> x.shutdown()); }
public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); static final String NODE_VERSION; final Reporter reporter; final BufferedLogger logger; public NetConfig netConfig; public NetworkV2 network; final Config config; public NodeInfo myInfo; public Node node; public ItemCache cache; public ParcelCache parcelCache; public PaidOperationCache paidOperationCache; }
@Test public void ecsrowInternalComplete() throws Exception { List<Main> mm = new ArrayList<>(); for (int i = 0; i < 4; i++) mm.add(createMain("node" + (i + 1), false)); Main main = mm.get(0); main.config.setIsFreeRegistrationsAllowedFromYaml(true); Client client = new Client(TestKeys.privateKey(20), main.myInfo, null); Set<PrivateKey> issuerPrivateKeys = new HashSet<>(asList(TestKeys.privateKey(0))); Set<PrivateKey> customerPrivateKeys = new HashSet<>(asList(TestKeys.privateKey(1))); Set<PrivateKey> arbitratorPrivateKeys = new HashSet<>(asList(TestKeys.privateKey(2))); Set<PrivateKey> executorPrivateKeys = new HashSet<>(asList(TestKeys.privateKey(3))); Set<PublicKey> issuerPublicKeys = new HashSet<>(); for (PrivateKey pk : issuerPrivateKeys) { issuerPublicKeys.add(pk.getPublicKey()); } Set<PublicKey> customerPublicKeys = new HashSet<>(); for (PrivateKey pk : customerPrivateKeys) { customerPublicKeys.add(pk.getPublicKey()); } Set<PublicKey> executorPublicKeys = new HashSet<>(); for (PrivateKey pk : executorPrivateKeys) { executorPublicKeys.add(pk.getPublicKey()); } Set<PublicKey> arbitratorPublicKeys = new HashSet<>(); for (PrivateKey pk : arbitratorPrivateKeys) { arbitratorPublicKeys.add(pk.getPublicKey()); } Contract payment = InnerContractsService.createFreshU(100, customerPublicKeys, true); payment.check(); payment.traceErrors(); ItemResult itemResult = client.register(payment.getPackedTransaction(), 5000); System.out.println("payment : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); payment = payment.createRevision(customerPrivateKeys); Contract escrow = ContractsService.createInternalEscrowContract(issuerPrivateKeys, customerPublicKeys, executorPublicKeys, arbitratorPublicKeys); assertEquals(escrow.getStateData().getString("status", "null"), "opened"); escrow.getStateData().set("description", "Simple escrow"); escrow.getStateData().set("percent", 10); escrow.seal(); payment = ContractsService.modifyPaymentForEscrowContract(escrow, payment, customerPrivateKeys, customerPublicKeys, executorPublicKeys); assertTrue(payment.findReferenceByName("return_payment_to_customer", "transactional") != null); assertTrue(payment.findReferenceByName("send_payment_to_executor", "transactional") != null); escrow.check(); escrow.traceErrors(); itemResult = client.register(escrow.getPackedTransaction(), 5000); System.out.println("escrow : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); itemResult = client.register(payment.getPackedTransaction(), 5000); System.out.println("payment : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); Contract completedEscrow = ContractsService.completeEscrowContract(escrow); assertEquals(completedEscrow.getStateData().getString("status", "null"), "completed"); completedEscrow.addSignatureToSeal(issuerPrivateKeys); completedEscrow = Contract.fromPackedTransaction(completedEscrow.getPackedTransaction()); completedEscrow.addSignatureToSeal(customerPrivateKeys); completedEscrow = Contract.fromPackedTransaction(completedEscrow.getPackedTransaction()); completedEscrow.addSignatureToSeal(executorPrivateKeys); assertEquals(completedEscrow.getStateData().getString("description", "null"), "Simple escrow"); assertEquals(completedEscrow.getStateData().getLong("percent", 0), 10); completedEscrow.check(); completedEscrow.traceErrors(); itemResult = client.register(completedEscrow.getPackedTransaction(), 5000); System.out.println("completedEscrow : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); Contract newPayment = ContractsService.takeEscrowPayment(executorPrivateKeys, payment); newPayment.getTransactionPack().addReferencedItem(completedEscrow); newPayment.check(); newPayment.traceErrors(); itemResult = client.register(newPayment.getPackedTransaction(), 5000); System.out.println("newPayment : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); mm.forEach(x -> x.shutdown()); }
public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); static final String NODE_VERSION; final Reporter reporter; final BufferedLogger logger; public NetConfig netConfig; public NetworkV2 network; final Config config; public NodeInfo myInfo; public Node node; public ItemCache cache; public ParcelCache parcelCache; public PaidOperationCache paidOperationCache; }
@Test public void ecsrowInternalCancel() throws Exception { List<Main> mm = new ArrayList<>(); for (int i = 0; i < 4; i++) mm.add(createMain("node" + (i + 1), false)); Main main = mm.get(0); main.config.setIsFreeRegistrationsAllowedFromYaml(true); Client client = new Client(TestKeys.privateKey(20), main.myInfo, null); Set<PrivateKey> issuerPrivateKeys = new HashSet<>(asList(TestKeys.privateKey(0))); Set<PrivateKey> customerPrivateKeys = new HashSet<>(asList(TestKeys.privateKey(1))); Set<PrivateKey> arbitratorPrivateKeys = new HashSet<>(asList(TestKeys.privateKey(2))); Set<PrivateKey> executorPrivateKeys = new HashSet<>(asList(TestKeys.privateKey(3))); Set<PublicKey> issuerPublicKeys = new HashSet<>(); for (PrivateKey pk : issuerPrivateKeys) { issuerPublicKeys.add(pk.getPublicKey()); } Set<PublicKey> customerPublicKeys = new HashSet<>(); for (PrivateKey pk : customerPrivateKeys) { customerPublicKeys.add(pk.getPublicKey()); } Set<PublicKey> executorPublicKeys = new HashSet<>(); for (PrivateKey pk : executorPrivateKeys) { executorPublicKeys.add(pk.getPublicKey()); } Set<PublicKey> arbitratorPublicKeys = new HashSet<>(); for (PrivateKey pk : arbitratorPrivateKeys) { arbitratorPublicKeys.add(pk.getPublicKey()); } Contract payment = InnerContractsService.createFreshU(100, customerPublicKeys, true); payment.check(); payment.traceErrors(); ItemResult itemResult = client.register(payment.getPackedTransaction(), 5000); System.out.println("payment : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); payment = payment.createRevision(customerPrivateKeys); Contract escrow = ContractsService.createInternalEscrowContract(issuerPrivateKeys, customerPublicKeys, executorPublicKeys, arbitratorPublicKeys); assertEquals(escrow.getStateData().getString("status", "null"), "opened"); escrow.getStateData().set("description", "Simple escrow"); escrow.getStateData().set("percent", 10); escrow.seal(); payment = ContractsService.modifyPaymentForEscrowContract(escrow, payment, customerPrivateKeys, customerPublicKeys, executorPublicKeys); assertTrue(payment.findReferenceByName("return_payment_to_customer", "transactional") != null); assertTrue(payment.findReferenceByName("send_payment_to_executor", "transactional") != null); escrow.check(); escrow.traceErrors(); itemResult = client.register(escrow.getPackedTransaction(), 5000); System.out.println("escrow : " + itemResult); itemResult = client.register(payment.getPackedTransaction(), 5000); System.out.println("payment : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); Contract canceledEscrow = ContractsService.cancelEscrowContract(escrow); assertEquals(canceledEscrow.getStateData().getString("status", "null"), "canceled"); canceledEscrow.addSignatureToSeal(issuerPrivateKeys); canceledEscrow = Contract.fromPackedTransaction(canceledEscrow.getPackedTransaction()); canceledEscrow.addSignatureToSeal(customerPrivateKeys); canceledEscrow = Contract.fromPackedTransaction(canceledEscrow.getPackedTransaction()); canceledEscrow.addSignatureToSeal(arbitratorPrivateKeys); assertEquals(canceledEscrow.getStateData().getString("description", "null"), "Simple escrow"); assertEquals(canceledEscrow.getStateData().getLong("percent", 0), 10); canceledEscrow.check(); canceledEscrow.traceErrors(); itemResult = client.register(canceledEscrow.getPackedTransaction(), 5000); System.out.println("canceledEscrow : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); Contract newPayment = ContractsService.takeEscrowPayment(customerPrivateKeys, payment); newPayment.getTransactionPack().addReferencedItem(canceledEscrow); newPayment.check(); newPayment.traceErrors(); itemResult = client.register(newPayment.getPackedTransaction(), 5000); System.out.println("newPayment : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); mm.forEach(x -> x.shutdown()); }
public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); static final String NODE_VERSION; final Reporter reporter; final BufferedLogger logger; public NetConfig netConfig; public NetworkV2 network; final Config config; public NodeInfo myInfo; public Node node; public ItemCache cache; public ParcelCache parcelCache; public PaidOperationCache paidOperationCache; }
@Test public void ecsrowCompleteWithRepack() throws Exception { List<Main> mm = new ArrayList<>(); for (int i = 0; i < 4; i++) mm.add(createMain("node" + (i + 1), false)); Main main = mm.get(0); main.config.setIsFreeRegistrationsAllowedFromYaml(true); Client client = new Client(TestKeys.privateKey(20), main.myInfo, null); Set<PrivateKey> issuerPrivateKeys = new HashSet<>(asList(TestKeys.privateKey(0))); Set<PrivateKey> customerPrivateKeys = new HashSet<>(asList(TestKeys.privateKey(1))); Set<PrivateKey> arbitratorPrivateKeys = new HashSet<>(asList(TestKeys.privateKey(2))); Set<PrivateKey> executorPrivateKeys = new HashSet<>(asList(TestKeys.privateKey(3))); Set<PublicKey> issuerPublicKeys = new HashSet<>(); for (PrivateKey pk : issuerPrivateKeys) { issuerPublicKeys.add(pk.getPublicKey()); } Set<PublicKey> customerPublicKeys = new HashSet<>(); for (PrivateKey pk : customerPrivateKeys) { customerPublicKeys.add(pk.getPublicKey()); } Set<PublicKey> executorPublicKeys = new HashSet<>(); for (PrivateKey pk : executorPrivateKeys) { executorPublicKeys.add(pk.getPublicKey()); } Set<PublicKey> arbitratorPublicKeys = new HashSet<>(); for (PrivateKey pk : arbitratorPrivateKeys) { arbitratorPublicKeys.add(pk.getPublicKey()); } Contract payment = InnerContractsService.createFreshU(100, customerPublicKeys, true); payment.check(); payment.traceErrors(); ItemResult itemResult = client.register(payment.getPackedTransaction(), 5000); System.out.println("payment : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); payment = payment.createRevision(customerPrivateKeys); Contract escrow = ContractsService.createEscrowContract(issuerPrivateKeys, customerPublicKeys, executorPublicKeys, arbitratorPublicKeys); assertEquals(escrow.getDefinition().getData().getString("EscrowOrigin", "null"), escrow.getNew().get(0).getOrigin().toBase64String()); assertEquals(escrow.getNew().get(0).getStateData().getString("status", "null"), "opened"); Contract internalEscrow = escrow.getNew().get(0); internalEscrow.getStateData().set("description", "Simple internal escrow"); internalEscrow.getStateData().set("percent", 20); internalEscrow.seal(); escrow = ContractsService.createExternalEscrowContract(internalEscrow, issuerPrivateKeys); escrow.getStateData().set("description", "Simple external escrow"); escrow.getStateData().set("percent", 20); escrow.seal(); boolean result = ContractsService.addPaymentToEscrowContract(escrow, payment, customerPrivateKeys, customerPublicKeys, executorPublicKeys); assertTrue(result); assertTrue(payment.findReferenceByName("return_payment_to_customer", "transactional") != null); assertTrue(payment.findReferenceByName("send_payment_to_executor", "transactional") != null); escrow.check(); escrow.traceErrors(); itemResult = client.register(escrow.getPackedTransaction(), 5000); System.out.println("escrow : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); itemResult = main.node.waitItem(payment.getId(), 8000); assertEquals(ItemState.APPROVED, itemResult.state); Contract completedEscrow = ContractsService.completeEscrowContract(escrow); assertEquals(completedEscrow.getStateData().getString("status", "null"), "completed"); completedEscrow.addSignatureToSeal(issuerPrivateKeys); completedEscrow.addSignatureToSeal(customerPrivateKeys); completedEscrow.addSignatureToSeal(executorPrivateKeys); assertEquals(completedEscrow.getStateData().getString("description", "null"), "Simple internal escrow"); assertEquals(completedEscrow.getStateData().getLong("percent", 0), 20); assertEquals(escrow.getStateData().getString("description", "null"), "Simple external escrow"); assertEquals(escrow.getStateData().getLong("percent", 0), 20); completedEscrow.check(); completedEscrow.traceErrors(); itemResult = client.register(completedEscrow.getPackedTransaction(), 5000); System.out.println("completedEscrow : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); Contract newPayment = ContractsService.takeEscrowPayment(executorPrivateKeys, payment); newPayment.getTransactionPack().addReferencedItem(completedEscrow); newPayment.check(); newPayment.traceErrors(); itemResult = client.register(newPayment.getPackedTransaction(), 5000); System.out.println("newPayment : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); mm.forEach(x -> x.shutdown()); }
public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); static final String NODE_VERSION; final Reporter reporter; final BufferedLogger logger; public NetConfig netConfig; public NetworkV2 network; final Config config; public NodeInfo myInfo; public Node node; public ItemCache cache; public ParcelCache parcelCache; public PaidOperationCache paidOperationCache; }
@Test public void ecsrowReOpenFail() throws Exception { List<Main> mm = new ArrayList<>(); for (int i = 0; i < 4; i++) mm.add(createMain("node" + (i + 1), false)); Main main = mm.get(0); main.config.setIsFreeRegistrationsAllowedFromYaml(true); Client client = new Client(TestKeys.privateKey(20), main.myInfo, null); Set<PrivateKey> issuerPrivateKeys = new HashSet<>(asList(TestKeys.privateKey(0))); Set<PrivateKey> customerPrivateKeys = new HashSet<>(asList(TestKeys.privateKey(1))); Set<PrivateKey> arbitratorPrivateKeys = new HashSet<>(asList(TestKeys.privateKey(2))); Set<PrivateKey> executorPrivateKeys = new HashSet<>(asList(TestKeys.privateKey(3))); Set<PublicKey> issuerPublicKeys = new HashSet<>(); for (PrivateKey pk : issuerPrivateKeys) { issuerPublicKeys.add(pk.getPublicKey()); } Set<PublicKey> customerPublicKeys = new HashSet<>(); for (PrivateKey pk : customerPrivateKeys) { customerPublicKeys.add(pk.getPublicKey()); } Set<PublicKey> executorPublicKeys = new HashSet<>(); for (PrivateKey pk : executorPrivateKeys) { executorPublicKeys.add(pk.getPublicKey()); } Set<PublicKey> arbitratorPublicKeys = new HashSet<>(); for (PrivateKey pk : arbitratorPrivateKeys) { arbitratorPublicKeys.add(pk.getPublicKey()); } Contract payment = InnerContractsService.createFreshU(100, customerPublicKeys, true); payment.check(); payment.traceErrors(); ItemResult itemResult = client.register(payment.getPackedTransaction(), 5000); System.out.println("payment : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); payment = payment.createRevision(customerPrivateKeys); Contract escrow = ContractsService.createEscrowContract(issuerPrivateKeys, customerPublicKeys, executorPublicKeys, arbitratorPublicKeys); assertEquals(escrow.getDefinition().getData().getString("EscrowOrigin", "null"), escrow.getNew().get(0).getOrigin().toBase64String()); assertEquals(escrow.getNew().get(0).getStateData().getString("status", "null"), "opened"); boolean result = ContractsService.addPaymentToEscrowContract(escrow, payment, customerPrivateKeys, customerPublicKeys, executorPublicKeys); assertTrue(result); assertTrue(payment.findReferenceByName("return_payment_to_customer", "transactional") != null); assertTrue(payment.findReferenceByName("send_payment_to_executor", "transactional") != null); escrow.check(); escrow.traceErrors(); itemResult = client.register(escrow.getPackedTransaction(), 5000); System.out.println("escrow : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); itemResult = main.node.waitItem(payment.getId(), 8000); assertEquals(ItemState.APPROVED, itemResult.state); Contract canceledEscrow = ContractsService.cancelEscrowContract(escrow); assertEquals(canceledEscrow.getStateData().getString("status", "null"), "canceled"); canceledEscrow.addSignatureToSeal(issuerPrivateKeys); canceledEscrow.addSignatureToSeal(customerPrivateKeys); canceledEscrow.addSignatureToSeal(arbitratorPrivateKeys); canceledEscrow.check(); canceledEscrow.traceErrors(); itemResult = client.register(canceledEscrow.getPackedTransaction(), 5000); System.out.println("canceledEscrow : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); Contract revisionEscrow = canceledEscrow.createRevision(issuerPrivateKeys); revisionEscrow.getStateData().set("status", "opened"); revisionEscrow.seal(); revisionEscrow.addSignatureToSeal(customerPrivateKeys); revisionEscrow.addSignatureToSeal(executorPrivateKeys); revisionEscrow.addSignatureToSeal(arbitratorPrivateKeys); itemResult = client.register(revisionEscrow.getPackedTransaction(), 5000); System.out.println("revisionEscrow : " + itemResult); assertEquals(ItemState.DECLINED, itemResult.state); revisionEscrow = canceledEscrow.createRevision(issuerPrivateKeys); revisionEscrow.getStateData().set("status", "completed"); revisionEscrow.seal(); revisionEscrow.addSignatureToSeal(customerPrivateKeys); revisionEscrow.addSignatureToSeal(executorPrivateKeys); revisionEscrow.addSignatureToSeal(arbitratorPrivateKeys); itemResult = client.register(revisionEscrow.getPackedTransaction(), 5000); System.out.println("revisionEscrow : " + itemResult); assertEquals(ItemState.DECLINED, itemResult.state); Contract newPayment = ContractsService.takeEscrowPayment(customerPrivateKeys, payment); newPayment.getTransactionPack().addReferencedItem(canceledEscrow); newPayment.check(); newPayment.traceErrors(); itemResult = client.register(newPayment.getPackedTransaction(), 5000); System.out.println("newPayment : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); mm.forEach(x -> x.shutdown()); }
public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); static final String NODE_VERSION; final Reporter reporter; final BufferedLogger logger; public NetConfig netConfig; public NetworkV2 network; final Config config; public NodeInfo myInfo; public Node node; public ItemCache cache; public ParcelCache parcelCache; public PaidOperationCache paidOperationCache; }
@Test public void ecsrowTakePaymentFail() throws Exception { List<Main> mm = new ArrayList<>(); for (int i = 0; i < 4; i++) mm.add(createMain("node" + (i + 1), false)); Main main = mm.get(0); main.config.setIsFreeRegistrationsAllowedFromYaml(true); Client client = new Client(TestKeys.privateKey(20), main.myInfo, null); Set<PrivateKey> issuerPrivateKeys = new HashSet<>(asList(TestKeys.privateKey(0))); Set<PrivateKey> customerPrivateKeys = new HashSet<>(asList(TestKeys.privateKey(1))); Set<PrivateKey> arbitratorPrivateKeys = new HashSet<>(asList(TestKeys.privateKey(2))); Set<PrivateKey> executorPrivateKeys = new HashSet<>(asList(TestKeys.privateKey(3))); Set<PublicKey> issuerPublicKeys = new HashSet<>(); for (PrivateKey pk : issuerPrivateKeys) { issuerPublicKeys.add(pk.getPublicKey()); } Set<PublicKey> customerPublicKeys = new HashSet<>(); for (PrivateKey pk : customerPrivateKeys) { customerPublicKeys.add(pk.getPublicKey()); } Set<PublicKey> executorPublicKeys = new HashSet<>(); for (PrivateKey pk : executorPrivateKeys) { executorPublicKeys.add(pk.getPublicKey()); } Set<PublicKey> arbitratorPublicKeys = new HashSet<>(); for (PrivateKey pk : arbitratorPrivateKeys) { arbitratorPublicKeys.add(pk.getPublicKey()); } Contract payment = InnerContractsService.createFreshU(100, customerPublicKeys, true); payment.check(); payment.traceErrors(); ItemResult itemResult = client.register(payment.getPackedTransaction(), 5000); System.out.println("payment : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); payment = payment.createRevision(customerPrivateKeys); Contract escrow = ContractsService.createEscrowContract(issuerPrivateKeys, customerPublicKeys, executorPublicKeys, arbitratorPublicKeys); assertEquals(escrow.getDefinition().getData().getString("EscrowOrigin", "null"), escrow.getNew().get(0).getOrigin().toBase64String()); assertEquals(escrow.getNew().get(0).getStateData().getString("status", "null"), "opened"); boolean result = ContractsService.addPaymentToEscrowContract(escrow, payment, customerPrivateKeys, customerPublicKeys, executorPublicKeys); assertTrue(result); assertTrue(payment.findReferenceByName("return_payment_to_customer", "transactional") != null); assertTrue(payment.findReferenceByName("send_payment_to_executor", "transactional") != null); escrow.check(); escrow.traceErrors(); itemResult = client.register(escrow.getPackedTransaction(), 5000); System.out.println("escrow : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); itemResult = main.node.waitItem(payment.getId(), 8000); assertEquals(ItemState.APPROVED, itemResult.state); Contract newPayment = ContractsService.takeEscrowPayment(issuerPrivateKeys, payment); newPayment.getTransactionPack().addReferencedItem(escrow); newPayment.check(); newPayment.traceErrors(); itemResult = client.register(newPayment.getPackedTransaction(), 5000); System.out.println("newPayment : " + itemResult); assertEquals(ItemState.DECLINED, itemResult.state); newPayment = ContractsService.takeEscrowPayment(customerPrivateKeys, payment); newPayment.getTransactionPack().addReferencedItem(escrow); newPayment.check(); newPayment.traceErrors(); itemResult = client.register(newPayment.getPackedTransaction(), 5000); System.out.println("newPayment : " + itemResult); assertEquals(ItemState.DECLINED, itemResult.state); newPayment = ContractsService.takeEscrowPayment(executorPrivateKeys, payment); newPayment.getTransactionPack().addReferencedItem(escrow); newPayment.check(); newPayment.traceErrors(); itemResult = client.register(newPayment.getPackedTransaction(), 5000); System.out.println("newPayment : " + itemResult); assertEquals(ItemState.DECLINED, itemResult.state); mm.forEach(x -> x.shutdown()); }
public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); static final String NODE_VERSION; final Reporter reporter; final BufferedLogger logger; public NetConfig netConfig; public NetworkV2 network; final Config config; public NodeInfo myInfo; public Node node; public ItemCache cache; public ParcelCache parcelCache; public PaidOperationCache paidOperationCache; }
@Test public void testPermanetMode() throws Exception { List<Main> mm = new ArrayList<>(); for (int i = 0; i < 4; i++) mm.add(createMain("node" + (i + 1), "_permanet", false)); Main main = mm.get(0); main.config.setIsFreeRegistrationsAllowedFromYaml(true); main.config.getKeysWhiteList().add(TestKeys.publicKey(20)); Client client = new Client(TestKeys.privateKey(20), main.myInfo, null); assertTrue(main.config.isPermanetMode()); for (int i = 1; i < 4; i++) assertTrue(mm.get(i).config.isPermanetMode()); main.config.setPermanetMode(false); assertTrue(main.config.isPermanetMode()); Set<PrivateKey> privateKeys = new HashSet<>(asList(TestKeys.privateKey(0))); Set<PublicKey> publicKeys = new HashSet<>(); for (PrivateKey pk : privateKeys) { publicKeys.add(pk.getPublicKey()); } Contract payment = InnerContractsService.createFreshU(100, publicKeys, true); payment.check(); payment.traceErrors(); ItemResult itemResult = client.register(payment.getPackedTransaction(), 5000); System.out.println("payment : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); Thread.sleep(2000); for (int i = 1; i < 4; i++) { byte[] keeping = mm.get(i).node.getLedger().getKeepingItem(payment.getId()); assertNotNull(keeping); assertTrue(Arrays.equals(payment.getPackedTransaction(), keeping)); } Contract baseContract = Contract.fromDslFile(ROOT_PATH + "DeLoreanOwnership.yml"); PrivateKey manufacturePrivateKey = new PrivateKey(Do.read(ROOT_PATH + "_xer0yfe2nn1xthc.private.unikey")); baseContract.setExpiresAt(ZonedDateTime.now().plusSeconds(5)); baseContract.addSignerKey(manufacturePrivateKey); baseContract.seal(); baseContract.check(); baseContract.traceErrors(); itemResult = client.register(baseContract.getPackedTransaction(), 5000); System.out.println("contract : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); Thread.sleep(2000); for (int i = 1; i < 4; i++) { byte[] keeping = mm.get(i).node.getLedger().getKeepingItem(baseContract.getId()); assertNotNull(keeping); assertTrue(Arrays.equals(baseContract.getPackedTransaction(), keeping)); } Thread.sleep(8000); itemResult = client.getState(baseContract.getId()); System.out.println("expired : " + itemResult); assertEquals(ItemState.UNDEFINED, itemResult.state); for (int i = 1; i < 4; i++) { byte[] keeping = mm.get(i).node.getLedger().getKeepingItem(baseContract.getId()); assertNotNull(keeping); assertTrue(Arrays.equals(baseContract.getPackedTransaction(), keeping)); } main.config.setIsFreeRegistrationsAllowedFromYaml(false); Contract parcelContract = Contract.fromDslFile(ROOT_PATH + "LamborghiniOwnership.yml"); parcelContract.setOwnerKeys(TestKeys.privateKey(1).getPublicKey()); parcelContract.addSignerKey(manufacturePrivateKey); parcelContract.seal(); parcelContract.check(); parcelContract.traceErrors(); Parcel parcel = createParcelWithFreshU(client, parcelContract, privateKeys); client.registerParcelWithState(parcel.pack(), 8000); itemResult = client.getState(parcel.getPayloadContract().getId()); System.out.println("root : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); Thread.sleep(2000); for (int i = 1; i < 4; i++) { byte[] keeping = mm.get(i).node.getLedger().getKeepingItem(parcel.getPayloadContract().getId()); assertNotNull(keeping); assertTrue(Arrays.equals(parcel.getPayloadContract().getPackedTransaction(), keeping)); } Contract revisionContract = parcelContract.createRevision(manufacturePrivateKey); revisionContract.setOwnerKeys(TestKeys.privateKey(2).getPublicKey()); revisionContract.addSignerKey(TestKeys.privateKey(1)); revisionContract.seal(); revisionContract.check(); revisionContract.traceErrors(); parcel = createParcelWithFreshU(client, revisionContract, privateKeys); client.registerParcelWithState(parcel.pack(), 8000); itemResult = client.getState(parcel.getPayloadContract().getId()); System.out.println("revision : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); itemResult = client.getState(parcelContract.getId()); System.out.println("root : " + itemResult); assertEquals(ItemState.REVOKED, itemResult.state); Thread.sleep(2000); for (int i = 1; i < 4; i++) { byte[] keeping_root = mm.get(i).node.getLedger().getKeepingItem(parcelContract.getId()); byte[] keeping_revision = mm.get(i).node.getLedger().getKeepingItem(revisionContract.getId()); assertNotNull(keeping_root); assertNotNull(keeping_revision); assertTrue(Arrays.equals(parcelContract.getPackedTransaction(), keeping_root)); assertTrue(Arrays.equals(revisionContract.getPackedTransaction(), keeping_revision)); } Contract revokeContract = ContractsService.createRevocation(revisionContract, manufacturePrivateKey); revokeContract.seal(); revokeContract.check(); revokeContract.traceErrors(); parcel = createParcelWithFreshU(client, revokeContract, privateKeys); client.registerParcelWithState(parcel.pack(), 8000); itemResult = client.getState(parcel.getPayloadContract().getId()); System.out.println("revocation : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); itemResult = client.getState(parcelContract.getId()); System.out.println("revision : " + itemResult); assertEquals(ItemState.REVOKED, itemResult.state); itemResult = client.getState(revisionContract.getId()); System.out.println("root : " + itemResult); assertEquals(ItemState.REVOKED, itemResult.state); Thread.sleep(2000); for (int i = 1; i < 4; i++) { byte[] keeping_root = mm.get(i).node.getLedger().getKeepingItem(parcelContract.getId()); byte[] keeping_revision = mm.get(i).node.getLedger().getKeepingItem(revisionContract.getId()); byte[] keeping_revoke = mm.get(i).node.getLedger().getKeepingItem(revokeContract.getId()); assertNotNull(keeping_root); assertNotNull(keeping_revision); assertNotNull(keeping_revoke); assertTrue(Arrays.equals(parcelContract.getPackedTransaction(), keeping_root)); assertTrue(Arrays.equals(revisionContract.getPackedTransaction(), keeping_revision)); assertTrue(Arrays.equals(revokeContract.getPackedTransaction(), keeping_revoke)); } HashSet<PrivateKey> own = new HashSet<>(Do.listOf(manufacturePrivateKey)); Contract rootContract = ContractsService.createTokenContract(own, new HashSet<>(Do.listOf(manufacturePrivateKey.getPublicKey())), "10000"); rootContract.seal(); parcel = createParcelWithFreshU(client, rootContract, privateKeys); client.registerParcelWithState(parcel.pack(), 8000); itemResult = client.getState(parcel.getPayloadContract().getId()); System.out.println("root : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); List<Contract> splitres = ContractsService.createSplitJoin(Do.listOf(rootContract), Do.listOf("100", "200", "300", "400"), Do.listOf( TestKeys.publicKey(1).getShortAddress(), TestKeys.publicKey(2).getShortAddress(), TestKeys.publicKey(3).getShortAddress(), TestKeys.publicKey(4).getShortAddress()), own, "amount"); parcel = createParcelWithFreshU(client, splitres.get(0), privateKeys); client.registerParcelWithState(parcel.pack(), 8000); itemResult = client.getState(parcel.getPayloadContract().getId()); System.out.println("split : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); List<HashId> ids = client.getChildren(rootContract.getId(), 5).getListOrThrow("ids"); System.out.println("children : " + ids); List<HashId> ids2 = client.getChildren(rootContract.getId(), 3).getListOrThrow("ids"); List<HashId> ids3 = client.getChildren(rootContract.getId(), 3, 3).getListOrThrow("ids"); HashSet set1 = new HashSet(ids); HashSet set2 = new HashSet(ids2); set2.addAll(ids3); assertEquals(set1, set2); assertEquals(ids.size(), splitres.size()); assertTrue(splitres.stream().allMatch(c -> ids.contains(c.getId()))); mm.forEach(x -> x.shutdown()); }
public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); static final String NODE_VERSION; final Reporter reporter; final BufferedLogger logger; public NetConfig netConfig; public NetworkV2 network; final Config config; public NodeInfo myInfo; public Node node; public ItemCache cache; public ParcelCache parcelCache; public PaidOperationCache paidOperationCache; }
@Test public void testPermanetModeSearchTags() throws Exception { List<Main> mm = new ArrayList<>(); for (int i = 0; i < 4; i++) mm.add(createMain("node" + (i + 1), "_permanet", false)); Main main = mm.get(0); main.config.setIsFreeRegistrationsAllowedFromYaml(true); main.config.getKeysWhiteList().add(TestKeys.publicKey(20)); Client client = new Client(TestKeys.privateKey(20), main.myInfo, null); for (int i = 0; i < 4; i++) { mm.get(i).config.setIsFreeRegistrationsAllowedFromYaml(true); assertTrue(mm.get(i).config.isPermanetMode()); } main.config.setPermanetMode(false); assertTrue(main.config.isPermanetMode()); String value1 = HashId.createRandom().toBase64String(); String value2 = HashId.createRandom().toBase64String(); String value3 = HashId.createRandom().toBase64String(); Contract c = new Contract(TestKeys.privateKey(1)); c.getDefinition().getData().put("search_tags",Binder.of("tag1",value1,"tag2",value2,"tag3",value3)); c.seal(); assertEquals(client.register(c.getPackedTransaction(),8000).state,ItemState.APPROVED); Binder res = client.getContract(null, Binder.of("tag1", value1, "any_of", Binder.of("tag2", value2, "tag3", "AAA")), 10, 0); assertEquals(res.getListOrThrow("contractIds").size(),1); res = client.getContract(null, Binder.of("tag1", value1, "all_of", Binder.of("tag2", value2, "tag3", "AAA")), 10, 0); assertNull(res); res = client.getContract(null, Binder.of("tag1", "AAA", "all_of", Binder.of("tag2", value2, "tag3", value3)), 10, 0); assertNull(res); res = client.getContract(null, Binder.of("tag1", value1, "all_of", Binder.of("tag2", value2, "tag3", value3)), 10, 0); assertEquals(res.getListOrThrow("contractIds").size(),1); mm.forEach(x -> x.shutdown()); }
public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); static final String NODE_VERSION; final Reporter reporter; final BufferedLogger logger; public NetConfig netConfig; public NetworkV2 network; final Config config; public NodeInfo myInfo; public Node node; public ItemCache cache; public ParcelCache parcelCache; public PaidOperationCache paidOperationCache; }
@Test public void testPermanetApiGetBodyGood() throws Exception { List<Main> mm = new ArrayList<>(); for (int i = 0; i < 4; i++) mm.add(createMain("node" + (i + 1), "_permanet", false)); Main main = mm.get(0); main.config.setIsFreeRegistrationsAllowedFromYaml(true); main.config.getKeysWhiteList().add(TestKeys.publicKey(20)); Client client = new Client(TestKeys.privateKey(20), main.myInfo, null); assertTrue(main.config.isPermanetMode()); for (int i = 1; i < 4; i++) assertTrue(mm.get(i).config.isPermanetMode()); main.config.setPermanetMode(false); assertTrue(main.config.isPermanetMode()); Set<PrivateKey> privateKeys = new HashSet<>(asList(TestKeys.privateKey(0))); Set<PublicKey> publicKeys = new HashSet<>(); for (PrivateKey pk : privateKeys) { publicKeys.add(pk.getPublicKey()); } Contract payment = InnerContractsService.createFreshU(100, publicKeys, true); payment.check(); payment.traceErrors(); ItemResult itemResult = client.register(payment.getPackedTransaction(), 5000); System.out.println("payment : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); Thread.sleep(2000); byte[] keeping = client.getBody(payment.getId()); assertNotNull(keeping); assertTrue(Arrays.equals(payment.getPackedTransaction(), keeping)); Contract baseContract = Contract.fromDslFile(ROOT_PATH + "DeLoreanOwnership.yml"); PrivateKey manufacturePrivateKey = new PrivateKey(Do.read(ROOT_PATH + "_xer0yfe2nn1xthc.private.unikey")); baseContract.setExpiresAt(ZonedDateTime.now().plusSeconds(5)); baseContract.addSignerKey(manufacturePrivateKey); baseContract.seal(); baseContract.check(); baseContract.traceErrors(); itemResult = client.register(baseContract.getPackedTransaction(), 5000); System.out.println("contract : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); Thread.sleep(2000); keeping = client.getBody(baseContract.getId()); assertNotNull(keeping); assertTrue(Arrays.equals(baseContract.getPackedTransaction(), keeping)); Thread.sleep(8000); itemResult = client.getState(baseContract.getId()); System.out.println("expired : " + itemResult); assertEquals(ItemState.UNDEFINED, itemResult.state); keeping = client.getBody(baseContract.getId()); assertNotNull(keeping); assertTrue(Arrays.equals(baseContract.getPackedTransaction(), keeping)); main.config.setIsFreeRegistrationsAllowedFromYaml(false); Contract parcelContract = Contract.fromDslFile(ROOT_PATH + "LamborghiniOwnership.yml"); parcelContract.setOwnerKeys(TestKeys.privateKey(1).getPublicKey()); parcelContract.addSignerKey(manufacturePrivateKey); parcelContract.seal(); parcelContract.check(); parcelContract.traceErrors(); Parcel parcel = createParcelWithFreshU(client, parcelContract, privateKeys); client.registerParcelWithState(parcel.pack(), 8000); itemResult = client.getState(parcel.getPayloadContract().getId()); System.out.println("root : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); Thread.sleep(2000); keeping = client.getBody(parcel.getPayloadContract().getId()); assertNotNull(keeping); assertTrue(Arrays.equals(parcel.getPayloadContract().getPackedTransaction(), keeping)); Contract revisionContract = parcelContract.createRevision(manufacturePrivateKey); revisionContract.setOwnerKeys(TestKeys.privateKey(2).getPublicKey()); revisionContract.addSignerKey(TestKeys.privateKey(1)); revisionContract.seal(); revisionContract.check(); revisionContract.traceErrors(); parcel = createParcelWithFreshU(client, revisionContract, privateKeys); client.registerParcelWithState(parcel.pack(), 8000); itemResult = client.getState(parcel.getPayloadContract().getId()); System.out.println("revision : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); itemResult = client.getState(parcelContract.getId()); System.out.println("root : " + itemResult); assertEquals(ItemState.REVOKED, itemResult.state); Thread.sleep(2000); byte[] keeping_root = client.getBody(parcelContract.getId()); byte[] keeping_revision = client.getBody(revisionContract.getId()); assertNotNull(keeping_root); assertNotNull(keeping_revision); assertTrue(Arrays.equals(parcelContract.getPackedTransaction(), keeping_root)); assertTrue(Arrays.equals(revisionContract.getPackedTransaction(), keeping_revision)); Contract revokeContract = ContractsService.createRevocation(revisionContract, manufacturePrivateKey); revokeContract.seal(); revokeContract.check(); revokeContract.traceErrors(); parcel = createParcelWithFreshU(client, revokeContract, privateKeys); client.registerParcelWithState(parcel.pack(), 8000); itemResult = client.getState(parcel.getPayloadContract().getId()); System.out.println("revocation : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); itemResult = client.getState(parcelContract.getId()); System.out.println("revision : " + itemResult); assertEquals(ItemState.REVOKED, itemResult.state); itemResult = client.getState(revisionContract.getId()); System.out.println("root : " + itemResult); assertEquals(ItemState.REVOKED, itemResult.state); Thread.sleep(2000); keeping_root = client.getBody(parcelContract.getId()); keeping_revision = client.getBody(revisionContract.getId()); byte[] keeping_revoke = client.getBody(revokeContract.getId()); assertNotNull(keeping_root); assertNotNull(keeping_revision); assertNotNull(keeping_revoke); assertTrue(Arrays.equals(parcelContract.getPackedTransaction(), keeping_root)); assertTrue(Arrays.equals(revisionContract.getPackedTransaction(), keeping_revision)); assertTrue(Arrays.equals(revokeContract.getPackedTransaction(), keeping_revoke)); mm.forEach(x -> x.shutdown()); }
public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); static final String NODE_VERSION; final Reporter reporter; final BufferedLogger logger; public NetConfig netConfig; public NetworkV2 network; final Config config; public NodeInfo myInfo; public Node node; public ItemCache cache; public ParcelCache parcelCache; public PaidOperationCache paidOperationCache; }
@Test public void testPermanetApiGetBodyNull() throws Exception { List<Main> mm = new ArrayList<>(); for (int i = 0; i < 4; i++) mm.add(createMain("node" + (i + 1), "_permanet", false)); Main main = mm.get(0); main.config.setIsFreeRegistrationsAllowedFromYaml(true); main.config.getKeysWhiteList().add(TestKeys.publicKey(20)); Client client = new Client(TestKeys.privateKey(20), main.myInfo, null); assertTrue(main.config.isPermanetMode()); for (int i = 1; i < 4; i++) assertTrue(mm.get(i).config.isPermanetMode()); main.config.setPermanetMode(false); assertTrue(main.config.isPermanetMode()); Set<PrivateKey> privateKeys = new HashSet<>(asList(TestKeys.privateKey(0))); Set<PublicKey> publicKeys = new HashSet<>(); for (PrivateKey pk : privateKeys) { publicKeys.add(pk.getPublicKey()); } Contract payment = InnerContractsService.createFreshU(100, publicKeys, true); payment.check(); payment.traceErrors(); ItemResult itemResult = client.register(payment.getPackedTransaction(), 5000); System.out.println("payment : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); Thread.sleep(2000); Contract baseContract = Contract.fromDslFile(ROOT_PATH + "DeLoreanOwnership.yml"); PrivateKey manufacturePrivateKey = new PrivateKey(Do.read(ROOT_PATH + "_xer0yfe2nn1xthc.private.unikey")); baseContract.setExpiresAt(ZonedDateTime.now().plusSeconds(5)); baseContract.addSignerKey(manufacturePrivateKey); baseContract.seal(); baseContract.check(); baseContract.traceErrors(); itemResult = client.register(baseContract.getPackedTransaction(), 5000); System.out.println("contract : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); Thread.sleep(2000); byte[] stranger = client.getBody(HashId.createRandom()); assertNull(stranger); mm.forEach(x -> x.shutdown()); }
public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); static final String NODE_VERSION; final Reporter reporter; final BufferedLogger logger; public NetConfig netConfig; public NetworkV2 network; final Config config; public NodeInfo myInfo; public Node node; public ItemCache cache; public ParcelCache parcelCache; public PaidOperationCache paidOperationCache; }
@Test public void checkSignatureWithCustomSalt() throws Exception { byte[] e = Hex.decode("010001"); byte[] p = Hex.decode("cd28ffefa9150bd3a8e9b0410e411920ed853c797e41038e9325125bb5fec3258eaba816fcc71ba86a2489da965d825fc0a3dabb31f5190ee80c2a0e7a73c9122e099b8a00c0a819e779e0b2cb07ca71acfb6209d8d607eb58ed314529eced00de559f3201bd3346a64c119cb92290d486a53f77087a232ea3fdb37946ad8e6dc6498da8defc63c30238d2622bcd58f3186e6e3d20f9b2872fd32127236d6eb4b57fa297c9814b2a3881fe2a538ed8d459f7f04faddbffc143f6e02b37d6b648b3c9df51aa7f2425e470ffe105d583c50d1a2da2c89f913a3af90a71ae2fafaff900e09ed4425f2a1c752b7e4f0c54b15640ae9adfd1c9cfcd75717d45a71381"); byte[] q = Hex.decode("fef327944862e322f6dae4649354af28bd32d938b0aeb8a25bf9186e6e3d20f9b2872fd32127236d6eb4b57fa26c2664af885a9e0830cf0a4a4b61d4e3650b3e0dd4507f21f2945479993d6a7d67d960017a42da25e470ff22fd6304e803bcb36cf1ec791ba1e4cc0a88863ca6d8e178a5cba71bb09504e2decfded5a81bbb01e43c02ea8ae795485864f91e3591f864c43da77a5993d213bab24cd9f95a2648f4cba8a56423e7b999b72fa4824f4bd95c5d61f4430e230b71473ef0cc530924654d0cb8c71f4ddba5007ceb93b80a466ec54665f9fe7b9c3804d7ebd13f0768af2d28cefa7240544cd2eb1815fbd40df864dcc4ad8bf4ac05383c56960b17c7"); byte[] nExpected = Hex.decode("cc518b92cef4a1baf1fe3fd3a4419bb5a0a5fe381c7d4b365dd672343a911236474a2fdff759dac21b40af42e83ec8ff30e403ed339faca0ab3a15f72a22dc822184a4949179590cbd53098d443fed61209a47223c4c6212e1b0085824d4ffd7f2d4927533f89a98132d070a61b062873c22b7ae65411a1ea6a9d33d30c5bbe63b19e05fe7589ac50ba5b704ee6fe9338d09dd7e9efd071534646101d058e676c9b650381ff5a0cdb2f11c3167378a25493957cb3ac71770a43cd77bc605b41f11c437560c0a0271154c4782f9c6a731477260e7334a380b81b197c1af53608d9ea451b136afdf7ada9ebba46db0a92464c7283b48a2eb332a89cc70ec02b8c66adc1e2344365db7f7bae30fe793e36eeacc93663969aca23a863556b2b9c4ff690f9f87994fa246c514bec71c91d0df26436934da51a6d484667d5e8f46f3599a8a5f52287dfd019e919ef4650406a44657f59342426ad61d33668b217ffe5f333c1858ce4cbbdcbbb71d486bca83f4eefed82088ea13e8b82288b639446831f61f298e96ebf5281056ed51d5f3e8e25c341386c699f4954a3f33a82efaf88e7d791e311bfbbcc947865349af32ddad1a5addafb10ff7401549a1c53bb7777533e269ec94e73d6f5927662c403a05b7b0541b3af816e91da94bbab8b095fedbb003253deffcbafb4190057f523564646d3f16d9e43a3b8be29a2694942bc047"); RSAOAEPPrivateKey privateKey = new RSAOAEPPrivateKey(e, p, q, HashType.SHA1, HashType.SHA1, new SecureRandom()); RSAOAEPPublicKey publicKey = (RSAOAEPPublicKey) privateKey.getPublicKey(); assertEquals(publicKey.state.keyParameters.getModulus(), BigIntegers.fromUnsignedByteArray(nExpected)); byte[] message = Hex.decode("4655424152206d65616e73204675636b6564205570204265796f756420416c6c205265636f676e6974696f6e"); byte[] signatureExpected = Hex.decode("78def239f5d4809c0557d11407c4825e6afb261873ab9f5d3e3fc22d4faa6c358b81c96d486ae2dbc8ad5ccecec6f49a0d5207579444b85ee4ec9a2d06a737a87717083282c4cf4af1ecc14a4fdfbdaa0d53e139fc77226bc4a01fe55bbc8a29403969911c3599508aaa8701f064b95e7e64b349e320724d6c9e2af5a8556d253bed772fb659bbee0e0a6dfe205d58f71f049b023d9ce8b278eaf3141cec06aab46e78cde55d3c403784819c34741deb681bdc2cee01c41e549f17aeb59ca80b8f045de1cf4ff983599e422bce2e68903d717291d897cf39961577e5fc9af9619379790628dbf369fee707a6a4daa3211ff840b46807351204acb60acc528099f851b8a76b4eaae5f84715ecc971c296f9cf3e058badc544a01e7d1dbef1c353d8704c6cffea9398e7ee6fda895d0dabc8ac18ed88c9497664c867e93e56fbebd4436eb3efa755f8fac3fa627e795be43d92d904fe0a9af989a6c504b1e11617d45b75cb5166795e58e69dfed4bf800f8088b0b48e12600c7f460bdaf34a1999d47ce3f5e11343d1e2b1797fc744aab9fcc938d08f70f91dd30c937e0515f8eb03e1a034044c33fbfbed83df5a1b7145ef0fcbb0f41f909793bd23bd964af1c5a53f72ef7b5920cd77d25cc2d9a7a38cbd86cbb3314222ae1ea3432f1370aefb1ea5780630b5f41c0cd408391537b05e242d0c7e0e6dadfd1de2c6c9500298c3"); int expectedSaltLength = 490; assertTrue(publicKey.checkSignature(message, signatureExpected, HashType.SHA1, expectedSaltLength)); assertTrue(publicKey.checkSignature(message, signatureExpected, HashType.SHA1)); assertFalse(publicKey.checkSignature(message, signatureExpected, HashType.SHA1, 0)); assertTrue(publicKey.checkSignature(message, privateKey.sign(message, HashType.SHA1), HashType.SHA1)); }
@NonNull @Override public boolean checkSignature(InputStream input, byte[] signature, HashType hashType, int saltLength) throws IllegalStateException, IOException { if (state == null) { throw new IllegalStateException(); } else { final Digest primaryDigest = hashType.makeDigest(); if (saltLength == MAX_SALT_LENGTH) { saltLength = getMaxSaltLength(getBitStrength(), primaryDigest.getDigestSize()); } if (saltLength < 0) { throw new RuntimeException(String.format("Incorrect salt length %s", saltLength)); } final Signer signatureChecker = new PSSSigner( RSAEngineFactory.make(), primaryDigest, state.mgf1HashType.makeDigest(), saltLength); signatureChecker.init(false, new ParametersWithRandom(state.keyParameters, state.rng)); boolean done = false; while (!done) { int availableBytes = input.available(); if (availableBytes <= 0) { done = true; } else { byte[] buffer = new byte[availableBytes]; int howManyBytesRead = input.read(buffer); if (howManyBytesRead <= 0) { done = true; } else { signatureChecker.update(buffer, 0, howManyBytesRead); } } } return signatureChecker.verifySignature(signature); } }
RSAOAEPPublicKey extends AbstractPublicKey { @NonNull @Override public boolean checkSignature(InputStream input, byte[] signature, HashType hashType, int saltLength) throws IllegalStateException, IOException { if (state == null) { throw new IllegalStateException(); } else { final Digest primaryDigest = hashType.makeDigest(); if (saltLength == MAX_SALT_LENGTH) { saltLength = getMaxSaltLength(getBitStrength(), primaryDigest.getDigestSize()); } if (saltLength < 0) { throw new RuntimeException(String.format("Incorrect salt length %s", saltLength)); } final Signer signatureChecker = new PSSSigner( RSAEngineFactory.make(), primaryDigest, state.mgf1HashType.makeDigest(), saltLength); signatureChecker.init(false, new ParametersWithRandom(state.keyParameters, state.rng)); boolean done = false; while (!done) { int availableBytes = input.available(); if (availableBytes <= 0) { done = true; } else { byte[] buffer = new byte[availableBytes]; int howManyBytesRead = input.read(buffer); if (howManyBytesRead <= 0) { done = true; } else { signatureChecker.update(buffer, 0, howManyBytesRead); } } } return signatureChecker.verifySignature(signature); } } }
RSAOAEPPublicKey extends AbstractPublicKey { @NonNull @Override public boolean checkSignature(InputStream input, byte[] signature, HashType hashType, int saltLength) throws IllegalStateException, IOException { if (state == null) { throw new IllegalStateException(); } else { final Digest primaryDigest = hashType.makeDigest(); if (saltLength == MAX_SALT_LENGTH) { saltLength = getMaxSaltLength(getBitStrength(), primaryDigest.getDigestSize()); } if (saltLength < 0) { throw new RuntimeException(String.format("Incorrect salt length %s", saltLength)); } final Signer signatureChecker = new PSSSigner( RSAEngineFactory.make(), primaryDigest, state.mgf1HashType.makeDigest(), saltLength); signatureChecker.init(false, new ParametersWithRandom(state.keyParameters, state.rng)); boolean done = false; while (!done) { int availableBytes = input.available(); if (availableBytes <= 0) { done = true; } else { byte[] buffer = new byte[availableBytes]; int howManyBytesRead = input.read(buffer); if (howManyBytesRead <= 0) { done = true; } else { signatureChecker.update(buffer, 0, howManyBytesRead); } } } return signatureChecker.verifySignature(signature); } } RSAOAEPPublicKey(); RSAOAEPPublicKey(byte[] n, byte[] e, HashType oaepHashType, HashType mgf1HashType, SecureRandom rng); }
RSAOAEPPublicKey extends AbstractPublicKey { @NonNull @Override public boolean checkSignature(InputStream input, byte[] signature, HashType hashType, int saltLength) throws IllegalStateException, IOException { if (state == null) { throw new IllegalStateException(); } else { final Digest primaryDigest = hashType.makeDigest(); if (saltLength == MAX_SALT_LENGTH) { saltLength = getMaxSaltLength(getBitStrength(), primaryDigest.getDigestSize()); } if (saltLength < 0) { throw new RuntimeException(String.format("Incorrect salt length %s", saltLength)); } final Signer signatureChecker = new PSSSigner( RSAEngineFactory.make(), primaryDigest, state.mgf1HashType.makeDigest(), saltLength); signatureChecker.init(false, new ParametersWithRandom(state.keyParameters, state.rng)); boolean done = false; while (!done) { int availableBytes = input.available(); if (availableBytes <= 0) { done = true; } else { byte[] buffer = new byte[availableBytes]; int howManyBytesRead = input.read(buffer); if (howManyBytesRead <= 0) { done = true; } else { signatureChecker.update(buffer, 0, howManyBytesRead); } } } return signatureChecker.verifySignature(signature); } } RSAOAEPPublicKey(); RSAOAEPPublicKey(byte[] n, byte[] e, HashType oaepHashType, HashType mgf1HashType, SecureRandom rng); @Override String toString(); @Override boolean canEncrypt(); @Override int getBitStrength(); @Override boolean isInitialized(); @NonNull @Override byte[] encrypt(byte[] plaintext); @NonNull @Override boolean checkSignature(InputStream input, byte[] signature, HashType hashType, int saltLength); @NonNull @Override String algorithmTag(); @NonNull @Override Map<String, Object> toHash(); @Override void updateFromHash(Map<String, Object> hash); }
RSAOAEPPublicKey extends AbstractPublicKey { @NonNull @Override public boolean checkSignature(InputStream input, byte[] signature, HashType hashType, int saltLength) throws IllegalStateException, IOException { if (state == null) { throw new IllegalStateException(); } else { final Digest primaryDigest = hashType.makeDigest(); if (saltLength == MAX_SALT_LENGTH) { saltLength = getMaxSaltLength(getBitStrength(), primaryDigest.getDigestSize()); } if (saltLength < 0) { throw new RuntimeException(String.format("Incorrect salt length %s", saltLength)); } final Signer signatureChecker = new PSSSigner( RSAEngineFactory.make(), primaryDigest, state.mgf1HashType.makeDigest(), saltLength); signatureChecker.init(false, new ParametersWithRandom(state.keyParameters, state.rng)); boolean done = false; while (!done) { int availableBytes = input.available(); if (availableBytes <= 0) { done = true; } else { byte[] buffer = new byte[availableBytes]; int howManyBytesRead = input.read(buffer); if (howManyBytesRead <= 0) { done = true; } else { signatureChecker.update(buffer, 0, howManyBytesRead); } } } return signatureChecker.verifySignature(signature); } } RSAOAEPPublicKey(); RSAOAEPPublicKey(byte[] n, byte[] e, HashType oaepHashType, HashType mgf1HashType, SecureRandom rng); @Override String toString(); @Override boolean canEncrypt(); @Override int getBitStrength(); @Override boolean isInitialized(); @NonNull @Override byte[] encrypt(byte[] plaintext); @NonNull @Override boolean checkSignature(InputStream input, byte[] signature, HashType hashType, int saltLength); @NonNull @Override String algorithmTag(); @NonNull @Override Map<String, Object> toHash(); @Override void updateFromHash(Map<String, Object> hash); static final HashType DEFAULT_OAEP_HASH; static final HashType DEFAULT_MGF1_HASH; }
@Test public void testPermanetApiGetBodyResync() throws Exception { List<Main> mm = new ArrayList<>(); for (int i = 0; i < 4; i++) mm.add(createMain("node" + (i + 1), "_permanet", false)); Main main = mm.get(0); main.config.setIsFreeRegistrationsAllowedFromYaml(true); main.config.getKeysWhiteList().add(TestKeys.publicKey(20)); Client client = new Client(TestKeys.privateKey(20), main.myInfo, null); assertTrue(main.config.isPermanetMode()); for (int i = 1; i < 4; i++) assertTrue(mm.get(i).config.isPermanetMode()); main.config.setPermanetMode(false); assertTrue(main.config.isPermanetMode()); Set<PrivateKey> privateKeys = new HashSet<>(asList(TestKeys.privateKey(0))); Set<PublicKey> publicKeys = new HashSet<>(); for (PrivateKey pk : privateKeys) { publicKeys.add(pk.getPublicKey()); } Contract parcelContract = Contract.fromDslFile(ROOT_PATH + "LamborghiniOwnership.yml"); PrivateKey manufacturePrivateKey = new PrivateKey(Do.read(ROOT_PATH + "_xer0yfe2nn1xthc.private.unikey")); parcelContract.setOwnerKeys(TestKeys.privateKey(1).getPublicKey()); parcelContract.addSignerKey(manufacturePrivateKey); parcelContract.seal(); parcelContract.check(); parcelContract.traceErrors(); Parcel parcel = createParcelWithFreshU(client, parcelContract, privateKeys); client.registerParcelWithState(parcel.pack(), 8000); ItemResult itemResult = client.getState(parcel.getPayloadContract().getId()); System.out.println("root : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); Thread.sleep(2000); HashId origin = parcelContract.getId(); Db db = ((PostgresLedger) main.node.getLedger()).getDb(); try (PreparedStatement statement = db.statement("delete from kept_items where origin = ?")) { statement.setBytes(1, origin.getDigest()); db.updateWithStatement(statement); } catch (Exception e) { e.printStackTrace(); throw e; } assertNull(main.node.getLedger().getKeepingItem(parcelContract.getId())); byte[] keeping = client.getBody(parcel.getPayloadContract().getId()); assertNotNull(keeping); assertTrue(Arrays.equals(parcel.getPayloadContract().getPackedTransaction(), keeping)); Contract revisionContract = parcelContract.createRevision(manufacturePrivateKey); revisionContract.setOwnerKeys(TestKeys.privateKey(2).getPublicKey()); revisionContract.addSignerKey(TestKeys.privateKey(1)); revisionContract.seal(); revisionContract.check(); revisionContract.traceErrors(); parcel = createParcelWithFreshU(client, revisionContract, privateKeys); client.registerParcelWithState(parcel.pack(), 8000); itemResult = client.getState(parcel.getPayloadContract().getId()); System.out.println("revision : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); itemResult = client.getState(parcelContract.getId()); System.out.println("root : " + itemResult); assertEquals(ItemState.REVOKED, itemResult.state); Thread.sleep(2000); try (PreparedStatement statement = db.statement("delete from kept_items where origin = ?")) { statement.setBytes(1, origin.getDigest()); db.updateWithStatement(statement); } catch (Exception e) { e.printStackTrace(); throw e; } assertNull(main.node.getLedger().getKeepingItem(parcelContract.getId())); assertNull(main.node.getLedger().getKeepingItem(revisionContract.getId())); byte[] keeping_root = client.getBody(parcelContract.getId()); byte[] keeping_revision = client.getBody(revisionContract.getId()); assertNotNull(keeping_root); assertNotNull(keeping_revision); assertTrue(Arrays.equals(parcelContract.getPackedTransaction(), keeping_root)); assertTrue(Arrays.equals(revisionContract.getPackedTransaction(), keeping_revision)); Thread.sleep(2000); mm.forEach(x -> x.shutdown()); }
public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); static final String NODE_VERSION; final Reporter reporter; final BufferedLogger logger; public NetConfig netConfig; public NetworkV2 network; final Config config; public NodeInfo myInfo; public Node node; public ItemCache cache; public ParcelCache parcelCache; public PaidOperationCache paidOperationCache; }
@Test public void testGetContractAPIforOneActive() throws Exception { List<Main> mm = new ArrayList<>(); for (int i = 0; i < 4; i++) mm.add(createMain("node" + (i + 1), "_permanet", false)); Main main = mm.get(0); main.config.getKeysWhiteList().add(TestKeys.publicKey(20)); Client client = new Client(TestKeys.privateKey(20), main.myInfo, null); assertTrue(main.config.isPermanetMode()); for (int i = 1; i < 4; i++) assertTrue(mm.get(i).config.isPermanetMode()); main.config.setPermanetMode(false); assertTrue(main.config.isPermanetMode()); Set<PrivateKey> privateKeys = new HashSet<>(asList(TestKeys.privateKey(0))); Set<PublicKey> publicKeys = new HashSet<>(); for (PrivateKey pk : privateKeys) { publicKeys.add(pk.getPublicKey()); } PrivateKey manufacturePrivateKey = new PrivateKey(Do.read(ROOT_PATH + "_xer0yfe2nn1xthc.private.unikey")); Contract parcelContract = Contract.fromDslFile(ROOT_PATH + "LamborghiniOwnership.yml"); parcelContract.setOwnerKeys(TestKeys.privateKey(1).getPublicKey()); parcelContract.addSignerKey(manufacturePrivateKey); parcelContract.seal(); parcelContract.check(); parcelContract.traceErrors(); Parcel parcel = createParcelWithFreshU(client, parcelContract, privateKeys); client.registerParcelWithState(parcel.pack(), 8000); ItemResult itemResult = client.getState(parcel.getPayloadContract().getId()); System.out.println("root : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); Thread.sleep(2000); HashId origin = parcelContract.getId(); Binder result = client.getContract(origin); byte[] keeping_root = result.getBytesOrThrow("packedContract").toArray(); assertTrue(Arrays.equals(parcelContract.getPackedTransaction(), keeping_root)); Contract revisionContract = parcelContract.createRevision(manufacturePrivateKey); revisionContract.setOwnerKeys(TestKeys.privateKey(2).getPublicKey()); revisionContract.addSignerKey(TestKeys.privateKey(1)); revisionContract.seal(); revisionContract.check(); revisionContract.traceErrors(); parcel = createParcelWithFreshU(client, revisionContract, privateKeys); client.registerParcelWithState(parcel.pack(), 8000); itemResult = client.getState(parcel.getPayloadContract().getId()); System.out.println("revision : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); itemResult = client.getState(parcelContract.getId()); System.out.println("root : " + itemResult); assertEquals(ItemState.REVOKED, itemResult.state); Thread.sleep(2000); result = client.getContract(origin); byte[] keeping_revision = result.getBytesOrThrow("packedContract").toArray(); assertTrue(Arrays.equals(revisionContract.getPackedTransaction(), keeping_revision)); result = client.getContract(revisionContract.getId()); assertNull(result); Contract revokeContract = ContractsService.createRevocation(revisionContract, manufacturePrivateKey); revokeContract.seal(); revokeContract.check(); revokeContract.traceErrors(); parcel = createParcelWithFreshU(client, revokeContract, privateKeys); client.registerParcelWithState(parcel.pack(), 8000); itemResult = client.getState(parcel.getPayloadContract().getId()); System.out.println("revocation : " + itemResult); assertEquals(ItemState.APPROVED, itemResult.state); itemResult = client.getState(parcelContract.getId()); System.out.println("revision : " + itemResult); assertEquals(ItemState.REVOKED, itemResult.state); itemResult = client.getState(revisionContract.getId()); System.out.println("root : " + itemResult); assertEquals(ItemState.REVOKED, itemResult.state); Thread.sleep(2000); result = client.getContract(origin); assertNull(result); mm.forEach(x -> x.shutdown()); }
public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); static final String NODE_VERSION; final Reporter reporter; final BufferedLogger logger; public NetConfig netConfig; public NetworkV2 network; final Config config; public NodeInfo myInfo; public Node node; public ItemCache cache; public ParcelCache parcelCache; public PaidOperationCache paidOperationCache; }
@Test public void testGetContractAPIforManyActive() throws Exception { List<Main> mm = new ArrayList<>(); for (int i = 0; i < 4; i++) mm.add(createMain("node" + (i + 1), "_permanet", false)); Main main = mm.get(0); main.config.setIsFreeRegistrationsAllowedFromYaml(true); main.config.getKeysWhiteList().add(TestKeys.publicKey(20)); Client client = new Client(TestKeys.privateKey(20), main.myInfo, null); assertTrue(main.config.isPermanetMode()); for (int i = 1; i < 4; i++) assertTrue(mm.get(i).config.isPermanetMode()); main.config.setPermanetMode(false); assertTrue(main.config.isPermanetMode()); Set<PrivateKey> issuerPrivateKeys = new HashSet<>(asList(TestKeys.privateKey(1))); Set<PublicKey> ownerPublicKeys = new HashSet<>(asList(TestKeys.publicKey(2))); Set<PrivateKey> issuerPrivateKeys2 = new HashSet<>(asList(TestKeys.privateKey(2))); List<Contract> splits = new ArrayList<>(); Integer amountTokens = 1000; Contract tokenContract = ContractsService.createTokenContract(issuerPrivateKeys, ownerPublicKeys, new BigDecimal("1000")); tokenContract.check(); tokenContract.traceErrors(); HashId origin = tokenContract.getId(); ItemResult itemResult = client.register(tokenContract.getPackedTransaction(), 5000); System.out.println("tokenContract : " + itemResult + " = " + amountTokens.toString()); assertEquals(ItemState.APPROVED, itemResult.state); for (Integer i = 1; i < 41; i++) { Contract contractRemainder = ContractsService.createSplit(tokenContract, new BigDecimal(i), "amount", issuerPrivateKeys2, true); Contract contractSplit = contractRemainder.getNew().get(0); amountTokens -= i; splits.add(contractSplit); itemResult = client.register(contractRemainder.getPackedTransaction(), 5000); System.out.println("contractRemainder : " + itemResult + " = " + amountTokens.toString()); assertEquals(ItemState.APPROVED, itemResult.state); assertEquals(amountTokens.toString(), contractRemainder.getStateData().get("amount").toString()); assertEquals(i.toString(), contractSplit.getStateData().get("amount").toString()); assertEquals(ItemState.REVOKED, main.node.waitItem(tokenContract.getId(), 5000).state); assertEquals(ItemState.APPROVED, main.node.waitItem(contractRemainder.getId(), 5000).state); assertEquals(ItemState.APPROVED, main.node.waitItem(contractSplit.getId(), 5000).state); tokenContract = contractRemainder; } Binder result = client.getContract(origin); List<byte[]> allKeepingIds = result.getListOrThrow("contractIds"); assertFalse(result.containsKey("packedContract")); assertEquals(allKeepingIds.size(), splits.size() + 1); final HashId hash = tokenContract.getId(); assertTrue(allKeepingIds.stream().anyMatch(id -> Arrays.equals(hash.getDigest(), id))); splits.forEach(s -> assertTrue(allKeepingIds.stream().anyMatch(id -> Arrays.equals(s.getId().getDigest(), id)))); result = client.getContract(origin, 10); List<byte[]> keepingIds = result.getListOrThrow("contractIds"); assertFalse(result.containsKey("packedContract")); assertEquals(keepingIds.size(), 10); assertTrue(keepingIds.stream().anyMatch(id -> Arrays.equals(hash.getDigest(), id))); for (int i = splits.size() - 1; i > splits.size() - 10; i--) { final HashId hashSplit = splits.get(i).getId(); assertTrue(keepingIds.stream().anyMatch(id -> Arrays.equals(hashSplit.getDigest(), id))); } mm.forEach(x -> x.config.setQueryContractsLimit(20)); result = client.getContract(origin); keepingIds = result.getListOrThrow("contractIds"); assertFalse(result.containsKey("packedContract")); assertEquals(keepingIds.size(), 20); assertTrue(keepingIds.stream().anyMatch(id -> Arrays.equals(hash.getDigest(), id))); for (int i = splits.size() - 1; i > splits.size() - 20; i--) { final HashId hashSplit = splits.get(i).getId(); assertTrue(keepingIds.stream().anyMatch(id -> Arrays.equals(hashSplit.getDigest(), id))); } result = client.getContract(origin, 30); keepingIds = result.getListOrThrow("contractIds"); assertFalse(result.containsKey("packedContract")); assertEquals(keepingIds.size(), 20); assertTrue(keepingIds.stream().anyMatch(id -> Arrays.equals(hash.getDigest(), id))); for (int i = splits.size() - 1; i > splits.size() - 20; i--) { final HashId hashSplit = splits.get(i).getId(); assertTrue(keepingIds.stream().anyMatch(id -> Arrays.equals(hashSplit.getDigest(), id))); } mm.forEach(x -> x.shutdown()); }
public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); static final String NODE_VERSION; final Reporter reporter; final BufferedLogger logger; public NetConfig netConfig; public NetworkV2 network; final Config config; public NodeInfo myInfo; public Node node; public ItemCache cache; public ParcelCache parcelCache; public PaidOperationCache paidOperationCache; }
@Test public void joinFromDifferentOwners() throws Exception { TestSpace ts = prepareTestSpace(); ts.nodes.forEach(m -> m.config.setIsFreeRegistrationsAllowedFromYaml(true)); Thread.sleep(2000); PrivateKey issuer = TestKeys.privateKey(11); PrivateKey owner1 = TestKeys.privateKey(12); PrivateKey owner2 = TestKeys.privateKey(13); PrivateKey owner3 = TestKeys.privateKey(14); Contract token = ContractsService.createTokenContract(new HashSet<>(Do.listOf(issuer)), new HashSet<>(Do.listOf(owner1.getPublicKey())), new BigDecimal("3000")); assertEquals(ts.client.register(token.getPackedTransaction(), 15000).state, ItemState.APPROVED); Contract part1 = token.createRevision(owner1); Contract[] parts = part1.split(2); Contract part2 = parts[0]; Contract part3 = parts[1]; part1.setOwnerKey(owner1.getPublicKey()); part1.getStateData().set("amount", "1000"); part2.setOwnerKey(owner2.getPublicKey()); part2.getStateData().set("amount", "1000"); part3.setOwnerKey(owner3.getPublicKey()); part3.getStateData().set("amount", "1000"); part2.seal(); part3.seal(); part1.seal(); ItemResult rr = ts.client.register(part1.getPackedTransaction(), 15000); System.out.println(rr.errors); assertEquals(rr.state, ItemState.APPROVED); assertEquals(ts.client.getState(part2.getId()).state, ItemState.APPROVED); assertEquals(ts.client.getState(part3.getId()).state, ItemState.APPROVED); part1 = Contract.fromPackedTransaction(part1.getPackedTransaction()); part2 = Contract.fromPackedTransaction(part2.getPackedTransaction()); part3 = Contract.fromPackedTransaction(part3.getPackedTransaction()); Contract badJoin = part1.createRevision(owner1); badJoin.addRevokingItems(part2); badJoin.addRevokingItems(part3); badJoin.getStateData().set("amount", "3000"); badJoin.seal(); badJoin.check(); assertEquals(ts.client.register(badJoin.getPackedTransaction(), 15000).state, ItemState.DECLINED); Contract goodJoin = part1.createRevision(owner1, owner2, owner3); goodJoin.addRevokingItems(part2); goodJoin.addRevokingItems(part3); goodJoin.getStateData().set("amount", "3000"); goodJoin.seal(); assertEquals(ts.client.register(goodJoin.getPackedTransaction(), 15000).state, ItemState.APPROVED); ts.nodes.forEach(m -> m.shutdown()); }
public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); static final String NODE_VERSION; final Reporter reporter; final BufferedLogger logger; public NetConfig netConfig; public NetworkV2 network; final Config config; public NodeInfo myInfo; public Node node; public ItemCache cache; public ParcelCache parcelCache; public PaidOperationCache paidOperationCache; }
@Test public void splitJoinCaseTest() throws Exception { TestSpace ts = prepareTestSpace(); ts.nodes.forEach(n -> n.config.setIsFreeRegistrationsAllowedFromYaml(true)); Set<PrivateKey> issuersPriv = new HashSet<>(); Set<PublicKey> ownersPub = new HashSet<>(); Set<PrivateKey> ownersPriv = new HashSet<>(); issuersPriv.add(TestKeys.privateKey(1)); ownersPub.add(TestKeys.publicKey(2)); ownersPriv.add(TestKeys.privateKey(2)); Contract token = ContractsService.createTokenContract(issuersPriv, ownersPub, new BigDecimal("10000")); assertTrue(token.check()); assertEquals(ts.client.register(token.getPackedTransaction(), 15000).state, ItemState.APPROVED); Contract token1 = ContractsService.createSplit(token, new BigDecimal("5000"), "amount", ownersPriv, true); assertTrue(token1.check()); Contract token2 = (Contract) token1.getNewItems().iterator().next(); token1 = Contract.fromPackedTransaction(token1.getPackedTransaction()); token2 = Contract.fromPackedTransaction(token2.getPackedTransaction()); assertEquals(ts.client.register(token1.getPackedTransaction(), 15000).state, ItemState.APPROVED); assertEquals(ts.client.getState(token2.getId()).state, ItemState.APPROVED); List<Contract> contracts = ContractsService.createSplitJoin(Do.listOf(token1, token2), Do.listOf("6000", "1000", "500", "500"), Do.listOf(TestKeys.publicKey(4).getShortAddress(), TestKeys.publicKey(5).getShortAddress(), TestKeys.publicKey(6).getShortAddress(), TestKeys.publicKey(7).getShortAddress()), ownersPriv, "amount"); assertEquals(ts.client.register(contracts.get(0).getPackedTransaction(), 15000).state, ItemState.APPROVED); ts.shutdown(); }
public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); static final String NODE_VERSION; final Reporter reporter; final BufferedLogger logger; public NetConfig netConfig; public NetworkV2 network; final Config config; public NodeInfo myInfo; public Node node; public ItemCache cache; public ParcelCache parcelCache; public PaidOperationCache paidOperationCache; }
@Test public void fakeParent() throws Exception { TestSpace ts = prepareTestSpace(); ts.nodes.forEach(n -> n.config.setIsFreeRegistrationsAllowedFromYaml(true)); Contract contract = new Contract(TestKeys.privateKey(1)); contract.seal(); assertEquals(ts.client.register(contract.getPackedTransaction(), 15000).state, ItemState.APPROVED); Contract contract2 = new Contract(TestKeys.privateKey(2)); contract2.addRevokingItems(contract); contract2.getState().setParent(contract.getId()); contract2.seal(); assertEquals(ts.client.register(contract2.getPackedTransaction(), 15000).state, ItemState.DECLINED); assertEquals(ts.client.getState(contract.getId()).state, ItemState.APPROVED); ts.shutdown(); }
public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); static final String NODE_VERSION; final Reporter reporter; final BufferedLogger logger; public NetConfig netConfig; public NetworkV2 network; final Config config; public NodeInfo myInfo; public Node node; public ItemCache cache; public ParcelCache parcelCache; public PaidOperationCache paidOperationCache; }
@Test public void informerTest() throws Exception { TestSpace ts = prepareTestSpace(); Contract payment = getApprovedUContract(ts); Set<PrivateKey> paymentKeys = new HashSet(); paymentKeys.add(ts.myKey); Contract c = new Contract(TestKeys.privateKey(1)); Binder s = BossBiMapper.serialize(c); ZonedDateTime cr = ZonedDateTime.now().minusMonths(1); s.getBinder("definition").set("created_at", cr); s.getBinder("state").set("created_at", cr); c = BossBiMapper.deserialize(s); c.getKeysToSignWith().add(TestKeys.privateKey(1)); c.seal(); Parcel parcel = ContractsService.createParcel(c, payment, 1, paymentKeys); ItemResult res = ts.client.registerParcelWithState(parcel.pack(), 15000); assertSame(res.state, ItemState.UNDEFINED); assertEquals(1, res.errors.size()); System.out.println(res.errors); payment = parcel.getPayment().getContract(); c = new Contract(TestKeys.privateKey(1)); for (int i = 0; i < 20; i++) { c.addNewItems(new Contract(TestKeys.privateKey(1))); } c.seal(); parcel = ContractsService.createParcel(c, payment, 1, paymentKeys); res = ts.client.registerParcelWithState(parcel.pack(), 15000); assertSame(res.state, ItemState.UNDEFINED); assertEquals(1, res.errors.size()); System.out.println(res.errors); payment = parcel.getPayment().getContract(); c = new Contract(TestKeys.privateKey(1)); Contract ri = new Contract(TestKeys.privateKey(2)); ri.seal(); c.addRevokingItems(ri); c.seal(); parcel = ContractsService.createParcel(c, payment, 1, paymentKeys); res = ts.client.registerParcelWithState(parcel.pack(), 15000); assertTrue(res.state == ItemState.DECLINED); assertEquals(1, res.errors.size()); System.out.println(res.errors); payment = parcel.getPayment().getContract(); c = new Contract(TestKeys.privateKey(1)); c.seal(); parcel = ContractsService.createParcel(c, payment, 1, paymentKeys); res = ts.client.registerParcelWithState(parcel.pack(), 15000); assertSame(res.state, ItemState.APPROVED); payment = parcel.getPayment().getContract(); c = new Contract(TestKeys.privateKey(1)); c.seal(); parcel = ContractsService.createParcel(c, payment, -1, paymentKeys); res = ts.client.registerParcelWithState(parcel.pack(), 15000); ItemResult state = ts.client.getState(parcel.getPaymentContract().getId()); assertSame(state.state, ItemState.DECLINED); assertSame(res.state, ItemState.UNDEFINED); assertEquals(0, res.errors.size()); ts.shutdown(); }
public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); static final String NODE_VERSION; final Reporter reporter; final BufferedLogger logger; public NetConfig netConfig; public NetworkV2 network; final Config config; public NodeInfo myInfo; public Node node; public ItemCache cache; public ParcelCache parcelCache; public PaidOperationCache paidOperationCache; }
@Test public void demo() throws Exception { PrivateKey person1 = TestKeys.privateKey(1); PrivateKey person2 = TestKeys.privateKey(2); PrivateKey bank = TestKeys.privateKey(3); Contract commissionAccRur = new Contract(bank); Contract commissionAccEur = new Contract(bank); commissionAccRur.getStateData().put(ACC_TYPE_FIELD, ACC_TYPE_BANK); commissionAccEur.getStateData().put(ACC_TYPE_FIELD, ACC_TYPE_BANK); commissionAccRur.getStateData().put(ACC_CURRENCY_FIELD, ACC_CURRENCY_RUR); commissionAccEur.getStateData().put(ACC_CURRENCY_FIELD, ACC_CURRENCY_EUR); commissionAccRur.getStateData().put(ACC_COMMISSION_PERCENT_FIELD, "0.0"); commissionAccEur.getStateData().put(ACC_COMMISSION_PERCENT_FIELD, "0.0"); commissionAccRur.getStateData().put(ACC_COMMISSION_ACCOUNT_FIELD, null); commissionAccEur.getStateData().put(ACC_COMMISSION_ACCOUNT_FIELD, null); commissionAccRur.seal(); commissionAccEur.seal(); Contract account1rur = new Contract(person1); Contract account2rur = new Contract(person2); Contract account2eur = new Contract(person2); account1rur.getStateData().put(ACC_TYPE_FIELD, ACC_TYPE_PERSONAL); account2rur.getStateData().put(ACC_TYPE_FIELD, ACC_TYPE_PERSONAL); account2eur.getStateData().put(ACC_TYPE_FIELD, ACC_TYPE_PERSONAL); account1rur.getStateData().put(ACC_CURRENCY_FIELD, ACC_CURRENCY_RUR); account2rur.getStateData().put(ACC_CURRENCY_FIELD, ACC_CURRENCY_RUR); account2eur.getStateData().put(ACC_CURRENCY_FIELD, ACC_CURRENCY_EUR); account1rur.getStateData().put(ACC_COMMISSION_PERCENT_FIELD, "0.1"); account2rur.getStateData().put(ACC_COMMISSION_PERCENT_FIELD, "0.0"); account2eur.getStateData().put(ACC_COMMISSION_PERCENT_FIELD, "0.2"); account1rur.getStateData().put(ACC_COMMISSION_ACCOUNT_FIELD, commissionAccRur.getId().toBase64String()); account2rur.getStateData().put(ACC_COMMISSION_ACCOUNT_FIELD, commissionAccRur.getId().toBase64String()); account2eur.getStateData().put(ACC_COMMISSION_ACCOUNT_FIELD, commissionAccEur.getId().toBase64String()); account1rur.seal(); account2rur.seal(); account2eur.seal(); Contract rurToken = new Contract(bank); SimpleRole tokenOwner = new SimpleRole("owner"); tokenOwner.addRequiredReference("canplayaccowner", Role.RequiredMode.ALL_OF); rurToken.registerRole(tokenOwner); rurToken.getStateData().put("account", account1rur.getId().toBase64String()); rurToken.getStateData().put(TOKEN_VALUE_FIELD, "100000"); RoleLink rl = new RoleLink("@owner", "owner"); rurToken.registerRole(rl); SplitJoinPermission sjp = new SplitJoinPermission(rl, Binder.of("field_name", TOKEN_VALUE_FIELD, "join_match_fields", Do.listOf("state.origin", TOKEN_ACCOUNT_PATH))); rurToken.addPermission(sjp); ModifyDataPermission mdp = new ModifyDataPermission(rl, Binder.of("fields", Binder.of(TOKEN_ACCOUNT_FIELD, null))); rurToken.addPermission(mdp); Reference canplayaccowner = new Reference(rurToken); canplayaccowner.name = "canplayaccowner"; List<String> conditions = new ArrayList<>(); conditions.add("ref.id==this." + TOKEN_ACCOUNT_PATH); conditions.add("this can_play ref.owner"); canplayaccowner.setConditions(Binder.of("all_of", conditions)); rurToken.addReference(canplayaccowner); Reference refAccount = new Reference(rurToken); refAccount.name = "refAccount"; refAccount.setConditions(Binder.of("all_of", Do.listOf("this." + TOKEN_ACCOUNT_PATH + " == ref.id"))); rurToken.addReference(refAccount); Reference refParent = new Reference(rurToken); refParent.name = "refParent"; refParent.setConditions(Binder.of("any_of", Do.listOf( "this.state.parent == ref.id", "this.state.parent undefined" ))); rurToken.addReference(refParent); Reference refParentAccount = new Reference(rurToken); refParentAccount.name = "refParentAccount"; refParentAccount.setConditions(Binder.of("any_of", Do.listOf( "refParent." + TOKEN_ACCOUNT_PATH + " == ref.id", "this.state.parent undefined" ))); rurToken.addReference(refParentAccount); Reference transferCheck = new Reference(rurToken); transferCheck.name = "transferCheck"; transferCheck.setConditions(Binder.of("any_of", Do.listOf( "this.state.parent undefined", "refParent." + TOKEN_ACCOUNT_PATH + " == this." + TOKEN_ACCOUNT_PATH, Binder.of("all_of", Do.listOf( "refAccount." + ACC_CURRENCY_PATH + " == refParentAccount." + ACC_CURRENCY_PATH, Binder.of("any_of", Do.listOf( Binder.of("all_of", Do.listOf( "this." + TOKEN_ACCOUNT_PATH + "==refParentAccount." + ACC_COMMISSION_ACCOUNT_PATH )), Binder.of("all_of", Do.listOf( "refParentAccount." + ACC_COMMISSION_PERCENT_PATH + "::number==0.0" )), Binder.of("all_of", Do.listOf( "ref." + TOKEN_VALUE_PATH + "::number == this." + TOKEN_VALUE_PATH + "::number * refParentAccount." + ACC_COMMISSION_PERCENT_PATH + "::number", "ref." + TOKEN_ACCOUNT_PATH + " == refParentAccount." + ACC_COMMISSION_ACCOUNT_PATH, "ref.transactional.data.transfer_id == this.id" )) )) )) ))); rurToken.addReference(transferCheck); rurToken.seal(); List<Main> mm = new ArrayList<>(); for (int i = 0; i < 4; i++) mm.add(createMain("node" + (i + 1), "_permanet", false)); Main main = mm.get(0); main.config.setIsFreeRegistrationsAllowedFromYaml(true); main.config.getKeysWhiteList().add(TestKeys.publicKey(20)); Client client = new Client(TestKeys.privateKey(20), main.myInfo, null); assertTrue(main.config.isPermanetMode()); for (int i = 1; i < 4; i++) assertTrue(mm.get(i).config.isPermanetMode()); assertEquals(client.register(commissionAccEur.getPackedTransaction(), 8000).state, ItemState.APPROVED); assertEquals(client.register(commissionAccRur.getPackedTransaction(), 8000).state, ItemState.APPROVED); assertEquals(client.register(account1rur.getPackedTransaction(), 8000).state, ItemState.APPROVED); assertEquals(client.register(account2rur.getPackedTransaction(), 8000).state, ItemState.APPROVED); assertEquals(client.register(account2eur.getPackedTransaction(), 8000).state, ItemState.APPROVED); rurToken.getTransactionPack().addReferencedItem(account1rur); ItemResult ir = client.register(rurToken.getPackedTransaction(), 8000); System.out.println(ir.errors); assertEquals(ir.state, ItemState.APPROVED); Contract[] result = makeTransfer(rurToken, new BigDecimal("5000"), account1rur, account2rur, commissionAccRur, new HashSet<>(Do.listOf(person1)), client); assertNotNull(result[2]); result = makeTransfer(result[1], new BigDecimal("2000"), account2rur, account1rur, commissionAccRur, new HashSet<>(Do.listOf(person2)), client); assertNull(result[2]); mm.forEach(m->m.shutdown()); }
public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); static final String NODE_VERSION; final Reporter reporter; final BufferedLogger logger; public NetConfig netConfig; public NetworkV2 network; final Config config; public NodeInfo myInfo; public Node node; public ItemCache cache; public ParcelCache parcelCache; public PaidOperationCache paidOperationCache; }
@Test public void multipleRevisions() throws Exception { TestSpace ts = prepareTestSpace(); ts.nodes.forEach(n -> n.config.setIsFreeRegistrationsAllowedFromYaml(true)); Contract c1 = new Contract(TestKeys.privateKey(1)); c1.seal(); ts.client.register(c1.getPackedTransaction(),8000); ts.clients.forEach(cl -> { try { assertEquals(cl.getState(c1.getId()).state, ItemState.APPROVED); } catch (ClientError clientError) { clientError.printStackTrace(); assertTrue(false); } }); Contract c2 = c1.createRevision(TestKeys.privateKey(1)); c2.setOwnerKeys(TestKeys.privateKey(2).getPublicKey()); c2.getKeysToSignWith().clear(); c2.seal(); Contract c3 = c2.createRevision(TestKeys.privateKey(2)); c3.setOwnerKeys(TestKeys.privateKey(3).getPublicKey()); c3.getKeysToSignWith().clear(); c3.seal(); Contract batch = ContractsService.createBatch(Do.listOf(TestKeys.privateKey(1), TestKeys.privateKey(2), TestKeys.privateKey(3)), c2,c3); ItemResult ir = ts.client.register(batch.getPackedTransaction(), 8000); System.out.println(ir.errors); assertEquals(ir.state,ItemState.APPROVED); ts.clients.forEach(cl -> { try { assertEquals(cl.getState(c2.getId()).state, ItemState.REVOKED); assertEquals(cl.getState(c3.getId()).state, ItemState.APPROVED); } catch (ClientError clientError) { clientError.printStackTrace(); assertTrue(false); } }); ts.shutdown(); }
public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); static final String NODE_VERSION; final Reporter reporter; final BufferedLogger logger; public NetConfig netConfig; public NetworkV2 network; final Config config; public NodeInfo myInfo; public Node node; public ItemCache cache; public ParcelCache parcelCache; public PaidOperationCache paidOperationCache; }
@Test public void multipleRevisionsRollback() throws Exception { TestSpace ts = prepareTestSpace(); ts.nodes.forEach(n -> n.config.setIsFreeRegistrationsAllowedFromYaml(true)); Contract c1 = new Contract(TestKeys.privateKey(1)); c1.seal(); ts.client.register(c1.getPackedTransaction(),8000); ts.clients.forEach(cl -> { try { assertEquals(cl.getState(c1.getId()).state, ItemState.APPROVED); } catch (ClientError clientError) { clientError.printStackTrace(); assertTrue(false); } }); Contract c2 = c1.createRevision(TestKeys.privateKey(1)); c2.setOwnerKeys(TestKeys.privateKey(2).getPublicKey()); c2.getKeysToSignWith().clear(); c2.seal(); Contract c3 = c2.createRevision(TestKeys.privateKey(2)); c3.setOwnerKeys(TestKeys.privateKey(3).getPublicKey()); c3.getKeysToSignWith().clear(); c3.seal(); Contract unregistered = new Contract(TestKeys.privateKey(10)); RoleLink rl = new RoleLink("@revoke", "owner"); unregistered.registerRole(rl); unregistered.addPermission(new RevokePermission(rl)); unregistered.getSealedByKeys().clear(); unregistered.seal(); System.out.println("=============================================="); Contract revokesUnregistered = new Contract(TestKeys.privateKey(10)); revokesUnregistered.addRevokingItems(unregistered); revokesUnregistered.seal(); ts.nodes.get(0).node.getLedger().findOrCreate(unregistered.getId()).setState(ItemState.APPROVED).save(); ts.nodes.get(1).node.getLedger().findOrCreate(unregistered.getId()).setState(ItemState.REVOKED).save(); Contract batch = ContractsService.createBatch(Do.listOf(TestKeys.privateKey(1), TestKeys.privateKey(2), TestKeys.privateKey(3)), c2,c3,revokesUnregistered); ItemResult ir = ts.client.register(batch.getPackedTransaction(), 8000); System.out.println(ir.errors); assertEquals(ir.state,ItemState.DECLINED); ts.clients.forEach(cl -> { try { assertEquals(cl.getState(c1.getId()).state, ItemState.APPROVED); assertEquals(cl.getState(c2.getId()).state, ItemState.UNDEFINED); assertEquals(cl.getState(c3.getId()).state, ItemState.UNDEFINED); } catch (ClientError clientError) { clientError.printStackTrace(); assertTrue(false); } }); ts.shutdown(); }
public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); static final String NODE_VERSION; final Reporter reporter; final BufferedLogger logger; public NetConfig netConfig; public NetworkV2 network; final Config config; public NodeInfo myInfo; public Node node; public ItemCache cache; public ParcelCache parcelCache; public PaidOperationCache paidOperationCache; }
@Test public void toHash() throws Exception { AbstractPublicKey rsaPublicKey = oaepSpec.getPublicKey(); Map mapRSA = rsaPublicKey.toHash(); assertArrayEquals((byte[]) mapRSA.get("n"), oaepSpec.n); assertArrayEquals((byte[]) mapRSA.get("e"), oaepSpec.e); assertFalse(mapRSA.containsKey("mgf1Hash")); AbstractPublicKey goodPublicKey1 = new RSAOAEPPublicKey( BigIntegers.asUnsignedByteArray(randomPublicKey1.getModulus()), BigIntegers.asUnsignedByteArray(randomPublicKey1.getExponent()), HashType.SHA512, HashType.SHA512, new SecureRandom()); Map map1 = goodPublicKey1.toHash(); assertArrayEquals((byte[]) map1.get("n"), BigIntegers.asUnsignedByteArray(randomPublicKey1.getModulus())); assertArrayEquals((byte[]) map1.get("e"), BigIntegers.asUnsignedByteArray(randomPublicKey1.getExponent())); assertEquals(map1.get("mgf1Hash"), "SHA-512"); }
@NonNull @Override public Map<String, Object> toHash() throws IllegalStateException { if (state == null) { throw new IllegalStateException(); } else { return Collections.unmodifiableMap(new HashMap<String, Object>() {{ put("n", BigIntegers.asUnsignedByteArray(state.keyParameters.getModulus())); put("e", BigIntegers.asUnsignedByteArray(state.keyParameters.getExponent())); if (!state.mgf1HashType.equals(DEFAULT_MGF1_HASH)) { put("mgf1Hash", state.mgf1HashType.getAlgorithmName()); } }}); } }
RSAOAEPPublicKey extends AbstractPublicKey { @NonNull @Override public Map<String, Object> toHash() throws IllegalStateException { if (state == null) { throw new IllegalStateException(); } else { return Collections.unmodifiableMap(new HashMap<String, Object>() {{ put("n", BigIntegers.asUnsignedByteArray(state.keyParameters.getModulus())); put("e", BigIntegers.asUnsignedByteArray(state.keyParameters.getExponent())); if (!state.mgf1HashType.equals(DEFAULT_MGF1_HASH)) { put("mgf1Hash", state.mgf1HashType.getAlgorithmName()); } }}); } } }
RSAOAEPPublicKey extends AbstractPublicKey { @NonNull @Override public Map<String, Object> toHash() throws IllegalStateException { if (state == null) { throw new IllegalStateException(); } else { return Collections.unmodifiableMap(new HashMap<String, Object>() {{ put("n", BigIntegers.asUnsignedByteArray(state.keyParameters.getModulus())); put("e", BigIntegers.asUnsignedByteArray(state.keyParameters.getExponent())); if (!state.mgf1HashType.equals(DEFAULT_MGF1_HASH)) { put("mgf1Hash", state.mgf1HashType.getAlgorithmName()); } }}); } } RSAOAEPPublicKey(); RSAOAEPPublicKey(byte[] n, byte[] e, HashType oaepHashType, HashType mgf1HashType, SecureRandom rng); }
RSAOAEPPublicKey extends AbstractPublicKey { @NonNull @Override public Map<String, Object> toHash() throws IllegalStateException { if (state == null) { throw new IllegalStateException(); } else { return Collections.unmodifiableMap(new HashMap<String, Object>() {{ put("n", BigIntegers.asUnsignedByteArray(state.keyParameters.getModulus())); put("e", BigIntegers.asUnsignedByteArray(state.keyParameters.getExponent())); if (!state.mgf1HashType.equals(DEFAULT_MGF1_HASH)) { put("mgf1Hash", state.mgf1HashType.getAlgorithmName()); } }}); } } RSAOAEPPublicKey(); RSAOAEPPublicKey(byte[] n, byte[] e, HashType oaepHashType, HashType mgf1HashType, SecureRandom rng); @Override String toString(); @Override boolean canEncrypt(); @Override int getBitStrength(); @Override boolean isInitialized(); @NonNull @Override byte[] encrypt(byte[] plaintext); @NonNull @Override boolean checkSignature(InputStream input, byte[] signature, HashType hashType, int saltLength); @NonNull @Override String algorithmTag(); @NonNull @Override Map<String, Object> toHash(); @Override void updateFromHash(Map<String, Object> hash); }
RSAOAEPPublicKey extends AbstractPublicKey { @NonNull @Override public Map<String, Object> toHash() throws IllegalStateException { if (state == null) { throw new IllegalStateException(); } else { return Collections.unmodifiableMap(new HashMap<String, Object>() {{ put("n", BigIntegers.asUnsignedByteArray(state.keyParameters.getModulus())); put("e", BigIntegers.asUnsignedByteArray(state.keyParameters.getExponent())); if (!state.mgf1HashType.equals(DEFAULT_MGF1_HASH)) { put("mgf1Hash", state.mgf1HashType.getAlgorithmName()); } }}); } } RSAOAEPPublicKey(); RSAOAEPPublicKey(byte[] n, byte[] e, HashType oaepHashType, HashType mgf1HashType, SecureRandom rng); @Override String toString(); @Override boolean canEncrypt(); @Override int getBitStrength(); @Override boolean isInitialized(); @NonNull @Override byte[] encrypt(byte[] plaintext); @NonNull @Override boolean checkSignature(InputStream input, byte[] signature, HashType hashType, int saltLength); @NonNull @Override String algorithmTag(); @NonNull @Override Map<String, Object> toHash(); @Override void updateFromHash(Map<String, Object> hash); static final HashType DEFAULT_OAEP_HASH; static final HashType DEFAULT_MGF1_HASH; }
@Test public void dupesTest() throws Exception { TestSpace ts = prepareTestSpace(); ts.nodes.forEach(n->n.config.setIsFreeRegistrationsAllowedFromYaml(true)); Contract c = new Contract(TestKeys.privateKey(1)); c.seal(); assertEquals(ts.client.register(c.getPackedTransaction(),9000).state,ItemState.APPROVED); Contract c1 = c.createRevision(TestKeys.privateKey(1)); c1.setOwnerKeys(TestKeys.privateKey(2)); c1.getState().setBranchNumber(1); Contract c2 = c.createRevision(TestKeys.privateKey(1)); c2.setOwnerKeys(TestKeys.privateKey(2)); c2.getState().setBranchNumber(2); Contract batch = ContractsService.createBatch(Do.listOf(TestKeys.privateKey(1)),c1,c2); ItemResult ir = ts.client.register(batch.getPackedTransaction(), 9000); System.out.println(ir.errors); assertEquals(ir.state,ItemState.DECLINED); ts.shutdown(); }
public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); static final String NODE_VERSION; final Reporter reporter; final BufferedLogger logger; public NetConfig netConfig; public NetworkV2 network; final Config config; public NodeInfo myInfo; public Node node; public ItemCache cache; public ParcelCache parcelCache; public PaidOperationCache paidOperationCache; }
@Test public void httpProxy() throws Exception { List<Main> nodes = new ArrayList<>(); for (int i = 0; i < 4; i++) nodes.add(createMain("node" + (i + 1), false)); nodes.forEach(n->n.config.setIsFreeRegistrationsAllowedFromYaml(true)); PrivateKey myKey = TestKeys.privateKey(3); ArrayList<Client> clientProxyToNode = new ArrayList<>(); for (int i = 0; i < 4; ++i) { Client clientProxyTo_i = new Client("./src/test_node_config_v2/test_node_config_v2.json",System.getProperty("java.io.tmpdir"),myKey); clientProxyTo_i.startProxyToNode(i, null); clientProxyToNode.add(clientProxyTo_i); } HashId testHashId = HashId.createRandom(); nodes.get(0).node.getLedger().findOrCreate(testHashId).setState(ItemState.APPROVED).save(); nodes.get(1).node.getLedger().findOrCreate(testHashId).setState(ItemState.DECLINED).save(); nodes.get(2).node.getLedger().findOrCreate(testHashId).setState(ItemState.REVOKED).save(); nodes.get(3).node.getLedger().findOrCreate(testHashId).setState(ItemState.DISCARDED).save(); System.out.println("\n\n-------------------"); ItemResult answer = clientProxyToNode.get(0).getState(testHashId); System.out.println(answer); assertEquals(ItemState.APPROVED, answer.state); answer = clientProxyToNode.get(1).getState(testHashId); System.out.println(answer); assertEquals(ItemState.DECLINED, answer.state); answer = clientProxyToNode.get(2).getState(testHashId); System.out.println(answer); assertEquals(ItemState.REVOKED, answer.state); answer = clientProxyToNode.get(3).getState(testHashId); System.out.println(answer); assertEquals(ItemState.DISCARDED, answer.state); System.out.println("-------------------\n\n"); nodes.forEach(n->n.shutdown()); }
public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); static final String NODE_VERSION; final Reporter reporter; final BufferedLogger logger; public NetConfig netConfig; public NetworkV2 network; final Config config; public NodeInfo myInfo; public Node node; public ItemCache cache; public ParcelCache parcelCache; public PaidOperationCache paidOperationCache; }
@Test public void httpProxyRecursion() throws Exception { List<Main> nodes = new ArrayList<>(); for (int i = 0; i < 4; i++) nodes.add(createMain("node" + (i + 1), false)); nodes.forEach(n->n.config.setIsFreeRegistrationsAllowedFromYaml(true)); PrivateKey myKey = TestKeys.privateKey(3); Client clientProxy = new Client("./src/test_node_config_v2/test_node_config_v2.json",System.getProperty("java.io.tmpdir"),myKey); clientProxy.startProxyToNode(1, null); HashId testHashId = HashId.createRandom(); nodes.get(0).node.getLedger().findOrCreate(testHashId).setState(ItemState.APPROVED).save(); nodes.get(1).node.getLedger().findOrCreate(testHashId).setState(ItemState.DECLINED).save(); nodes.get(2).node.getLedger().findOrCreate(testHashId).setState(ItemState.REVOKED).save(); nodes.get(3).node.getLedger().findOrCreate(testHashId).setState(ItemState.DISCARDED).save(); System.out.println("\n\n-------------------"); Client targetClient = clientProxy.getClient(2); BasicHttpClientSession targetSession = targetClient.getSession(); Binder cmd = Binder.of("command", "getState", "params", Binder.of("itemId", testHashId)); Binder commandParams = Binder.of("session_id", targetSession.getSessionId(), "params", targetSession.getSessionKey().etaEncrypt(Boss.pack(cmd))); Binder answer = clientProxy.command("proxy", "url", targetClient.getUrl(), "command", "proxyCommand", "params", commandParams); String answerError = answer.getStringOrThrow("error"); System.out.println("try recursion v1... answerError: " + answerError); assertEquals("COMMAND_FAILED [proxy] Unable to proxy command 'proxy'", answerError); System.out.println("-------------------\n\n"); nodes.forEach(n->n.shutdown()); }
public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); static final String NODE_VERSION; final Reporter reporter; final BufferedLogger logger; public NetConfig netConfig; public NetworkV2 network; final Config config; public NodeInfo myInfo; public Node node; public ItemCache cache; public ParcelCache parcelCache; public PaidOperationCache paidOperationCache; }
@Test public void httpProxyRecursion2() throws Exception { List<Main> nodes = new ArrayList<>(); for (int i = 0; i < 4; i++) nodes.add(createMain("node" + (i + 1), false)); nodes.forEach(n->n.config.setIsFreeRegistrationsAllowedFromYaml(true)); PrivateKey myKey = TestKeys.privateKey(3); Client clientProxy = new Client("./src/test_node_config_v2/test_node_config_v2.json",System.getProperty("java.io.tmpdir"),myKey); HashId testHashId = HashId.createRandom(); nodes.get(0).node.getLedger().findOrCreate(testHashId).setState(ItemState.APPROVED).save(); nodes.get(1).node.getLedger().findOrCreate(testHashId).setState(ItemState.DECLINED).save(); nodes.get(2).node.getLedger().findOrCreate(testHashId).setState(ItemState.REVOKED).save(); nodes.get(3).node.getLedger().findOrCreate(testHashId).setState(ItemState.DISCARDED).save(); System.out.println("\n\n-------------------"); Client targetClient1 = clientProxy.getClient(1); Client targetClient2 = clientProxy.getClient(2); BasicHttpClientSession targetSession1 = targetClient1.getSession(); BasicHttpClientSession targetSession2 = targetClient2.getSession(); Binder cmd2 = Binder.of("command", "getState", "params", Binder.of("itemId", testHashId)); Binder command2Params = Binder.of("session_id", targetSession2.getSessionId(), "params", targetSession2.getSessionKey().etaEncrypt(Boss.pack(cmd2))); Binder answer = clientProxy.command("proxy", "url", targetClient2.getUrl(), "command", "command", "params", command2Params); Binder answerBinder = Boss.load(answer.getBinaryOrThrow("result")); String answerError = answerBinder.getBinderOrThrow("response").getStringOrThrow("response"); System.out.println("try recursion v2... answerError: " + answerError); assertEquals("Access denied. Command 'command' is not allowed with 'proxy', use 'proxyCommand' instead.", answerError); System.out.println("-------------------\n\n"); nodes.forEach(n->n.shutdown()); }
public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); static final String NODE_VERSION; final Reporter reporter; final BufferedLogger logger; public NetConfig netConfig; public NetworkV2 network; final Config config; public NodeInfo myInfo; public Node node; public ItemCache cache; public ParcelCache parcelCache; public PaidOperationCache paidOperationCache; }
@Test public void networkStatusTest() throws Exception { TestSpace ts = prepareTestSpace(); ts.nodes.forEach(n-> { try { n.config.getAddressesWhiteList().add(TestKeys.publicKey(1).getLongAddress()); } catch (EncryptionError encryptionError) { encryptionError.printStackTrace(); } }); Client client = new Client("./src/test_node_config_v2/test_node_config_v2.json",System.getProperty("java.io.tmpdir"),TestKeys.privateKey(1)); HashId id1 = HashId.createRandom(); ts.nodes.forEach(n->n.node.getLedger().findOrCreate(id1).setState(ItemState.APPROVED).save()); assertTrue(client.isApprovedByNetwork(id1,0.9,3000)); HashId id2 = HashId.createRandom(); for(int i = 0; i < ts.nodes.size();i++) { ts.nodes.get(i).node.getLedger().findOrCreate(id2).setState(i==0?ItemState.DECLINED:ItemState.APPROVED); } for(int i = 0; i < 10;i++) { assertFalse(client.isApprovedByNetwork(id2, 0.8, 3000)); } ts.shutdown(); try { client.isApprovedByNetwork(HashId.createRandom(),0.1,3000); } catch (ClientError e) { System.out.println(e.getErrorRecord()); assertEquals(e.getErrorRecord().getError(), Errors.COMMAND_PENDING); } }
public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); static final String NODE_VERSION; final Reporter reporter; final BufferedLogger logger; public NetConfig netConfig; public NetworkV2 network; final Config config; public NodeInfo myInfo; public Node node; public ItemCache cache; public ParcelCache parcelCache; public PaidOperationCache paidOperationCache; }
@Test public void pingTest() throws Exception { TestSpace ts = prepareTestSpace(); ts.nodes.forEach(n-> { try { n.config.getAddressesWhiteList().add(TestKeys.publicKey(1).getLongAddress()); } catch (EncryptionError encryptionError) { encryptionError.printStackTrace(); } }); Client client1 = new Client("./src/test_node_config_v2/test_node_config_v2.json",System.getProperty("java.io.tmpdir"),TestKeys.privateKey(10)); try { Binder resErr = client1.getClient(0).pingNode(3,10000); fail(); } catch (Exception e) { System.out.println(e.getMessage()); } Client client = new Client("./src/test_node_config_v2/test_node_config_v2.json",System.getProperty("java.io.tmpdir"),TestKeys.privateKey(1)); try { Binder resErr = client.getClient(0).pingNode(33,10000); fail(); } catch (Exception e) { System.out.println(e.getMessage()); } for(int i = 0; i < client.size();i++) { for(int j = 0; j < client.size();j++) { if(j == i) continue; Binder res = client.getClient(i).pingNode(j + 1, 10000); System.out.println(i+"->"+j+" " +res); assertTrue(res.getIntOrThrow("UDP") >= 0); assertTrue(res.getIntOrThrow("UDP") < 10); assertTrue(res.getIntOrThrow("TCP") >= 0); assertTrue(res.getIntOrThrow("TCP") < 15); } } ts.nodes.remove(ts.nodes.size()-1).shutdown(); for(int i = 0; i < client.size()-1;i++) { for(int j = 0; j < client.size();j++) { if(j == i) continue; Binder res = client.getClient(i).pingNode(j + 1, 500); if(j < client.size()-1) { assertTrue(res.getIntOrThrow("UDP") >= 0); assertTrue(res.getIntOrThrow("UDP") < 10); assertTrue(res.getIntOrThrow("TCP") >= 0); assertTrue(res.getIntOrThrow("TCP") < 10); } else { assertEquals(res.getIntOrThrow("UDP"),-1); assertEquals(res.getIntOrThrow("TCP"),-1); } } } ts.shutdown(); }
public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); static final String NODE_VERSION; final Reporter reporter; final BufferedLogger logger; public NetConfig netConfig; public NetworkV2 network; final Config config; public NodeInfo myInfo; public Node node; public ItemCache cache; public ParcelCache parcelCache; public PaidOperationCache paidOperationCache; }
@Test public void secureLoanTestDefault() throws Exception{ TestSpace ts = prepareTestSpace(); ts.nodes.forEach(n->n.config.setIsFreeRegistrationsAllowedFromYaml(true)); PrivateKey lenderKey = TestKeys.privateKey(1); PrivateKey borrowerKey = TestKeys.privateKey(2); KeyAddress lenderAddress = lenderKey.getPublicKey().getLongAddress(); KeyAddress borrowerAddress = borrowerKey.getPublicKey().getLongAddress(); Contract token = ContractsService.createTokenContract(new HashSet<>(Do.listOf(TestKeys.privateKey(15))),new HashSet<>(Do.listOf(lenderKey.getPublicKey())),new BigDecimal("1000")); token.seal(); assertEquals(ts.client.register(token.getPackedTransaction(),8000).state,ItemState.APPROVED); token = ContractsService.createSplit(token,new BigDecimal("200"),"amount",new HashSet<>(Do.listOf(lenderKey))); token.setCreatorKeys(lenderKey.getPublicKey()); Contract rest = (Contract) token.getNewItems().iterator().next(); rest.setCreatorKeys(lenderKey.getPublicKey()); rest.setOwnerKeys(borrowerAddress); rest.seal(); token.seal(); ItemResult ir = ts.client.register(token.getPackedTransaction(), 8000); System.out.println(ir); assertEquals(ir.state,ItemState.APPROVED); Contract collateral = new Contract(TestKeys.privateKey(15)); collateral.setOwnerKeys(borrowerKey); collateral.getStateData().put("description","This is very valuable contract"); collateral.seal(); assertEquals(ts.client.register(collateral.getPackedTransaction(),8000).state,ItemState.APPROVED); Contract[] res = SecureLoanHelper.initSecureLoan(null,lenderAddress, borrowerAddress, token, Duration.ofSeconds(3), collateral, "1000",false,token.getOrigin(),null,null); Contract secureLoan = res[0]; secureLoan.addSignatureToSeal(borrowerKey); secureLoan.addSignatureToSeal(lenderKey); ir = ts.client.register(secureLoan.getPackedTransaction(), 8000); System.out.println(ir); assertEquals(ir.state,ItemState.APPROVED); Contract col1 = collateral.createRevision(borrowerKey,lenderKey); col1.setOwnerKeys(TestKeys.publicKey(4)); col1.seal(); col1.getTransactionPack().addReferencedItem(secureLoan); ir = ts.client.register(col1.getPackedTransaction(), 8000); System.out.println(ir); assertEquals(ir.state,ItemState.DECLINED); Contract defaultAttempt = SecureLoanHelper.defaultSecureLoan(secureLoan)[0]; defaultAttempt.addSignatureToSeal(lenderKey); ir = ts.client.register(defaultAttempt.getPackedTransaction(), 8000); System.out.println(ir); assertEquals(ir.state,ItemState.DECLINED); Thread.sleep(6000); res = SecureLoanHelper.defaultSecureLoan(secureLoan); secureLoan = res[0]; collateral = res[1]; secureLoan.addSignatureToSeal(lenderKey); ir = ts.client.register(secureLoan.getPackedTransaction(), 8000); System.out.println(ir); assertEquals(ir.state,ItemState.APPROVED); Contract col2 = collateral.createRevision(lenderKey); col2.setOwnerKeys(TestKeys.publicKey(4)); col2.seal(); col2 = Contract.fromPackedTransaction(col2.getPackedTransaction()); assertTrue(col2.check()); ir = ts.client.register(col2.getPackedTransaction(), 8000); System.out.println(ir); assertEquals(ir.state,ItemState.APPROVED); ts.shutdown(); }
public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); static final String NODE_VERSION; final Reporter reporter; final BufferedLogger logger; public NetConfig netConfig; public NetworkV2 network; final Config config; public NodeInfo myInfo; public Node node; public ItemCache cache; public ParcelCache parcelCache; public PaidOperationCache paidOperationCache; }
@Test public void secureLoanTestRepayment() throws Exception{ TestSpace ts = prepareTestSpace(); ts.nodes.forEach(n->n.config.setIsFreeRegistrationsAllowedFromYaml(true)); PrivateKey lenderKey = TestKeys.privateKey(1); PrivateKey borrowerKey = TestKeys.privateKey(2); KeyAddress lenderAddress = lenderKey.getPublicKey().getLongAddress(); KeyAddress borrowerAddress = borrowerKey.getPublicKey().getLongAddress(); Contract token = ContractsService.createTokenContract(new HashSet<>(Do.listOf(TestKeys.privateKey(15))),new HashSet<>(Do.listOf(lenderKey.getPublicKey())),"1000"); token.seal(); assertEquals(ts.client.register(token.getPackedTransaction(),8000).state,ItemState.APPROVED); token = ContractsService.createSplit(token,new BigDecimal("200"),"amount",new HashSet<>(Do.listOf(lenderKey))); token.setCreatorKeys(lenderAddress); Contract rest = (Contract) token.getNewItems().iterator().next(); rest.setCreatorKeys(lenderAddress); rest.setOwnerKeys(borrowerAddress); rest.seal(); token.seal(); assertEquals(ts.client.register(token.getPackedTransaction(),8000).state,ItemState.APPROVED); Contract collateral = new Contract(borrowerKey); collateral.getStateData().put("description","This is very valuable contract"); collateral.seal(); assertEquals(ts.client.register(collateral.getPackedTransaction(),8000).state,ItemState.APPROVED); Contract[] res = SecureLoanHelper.initSecureLoan(Binder.of("description","bla bla bla"),lenderAddress, borrowerAddress, token, Duration.ofSeconds(30), collateral, "1000",false,token.getOrigin(),null,null); Contract secureLoan = res[0]; secureLoan.addSignatureToSeal(borrowerKey); secureLoan.addSignatureToSeal(lenderKey); ItemResult ir = ts.client.register(secureLoan.getPackedTransaction(), 8000); System.out.println(ir); assertEquals(ir.state,ItemState.APPROVED); token = res[1]; token = token.createRevision(borrowerKey); token.addRevokingItems(rest); token.getStateData().set("amount","1000"); token.seal(); ir = ts.client.register(token.getPackedTransaction(),8000); System.out.println(ir); res = SecureLoanHelper.repaySecureLoan(secureLoan,token); secureLoan = res[0]; secureLoan.addSignatureToSeal(borrowerKey); ir = ts.client.register(secureLoan.getPackedTransaction(),8000); System.out.println(ir); assertEquals(ir.state,ItemState.APPROVED); Contract tokenAtempt = token.createRevision(lenderKey); tokenAtempt.setOwnerKeys(TestKeys.publicKey(5)); tokenAtempt.seal(); tokenAtempt.getTransactionPack().addReferencedItem(secureLoan); ir = ts.client.register(tokenAtempt.getPackedTransaction(),8000); System.out.println(ir); assertEquals(ir.state,ItemState.DECLINED); Contract collateralAtempt = collateral.createRevision(borrowerKey); collateralAtempt.setOwnerKeys(TestKeys.publicKey(5)); collateralAtempt.seal(); collateralAtempt.getTransactionPack().addReferencedItem(secureLoan); ir = ts.client.register(collateralAtempt.getPackedTransaction(),8000); System.out.println(ir); assertEquals(ir.state,ItemState.DECLINED); res = SecureLoanHelper.closeSecureLoan(secureLoan); secureLoan = res[0]; token = res[1]; collateral = res[2]; secureLoan.addSignatureToSeal(lenderKey); secureLoan.addSignatureToSeal(borrowerKey); ir = ts.client.register(secureLoan.getPackedTransaction(),8000); System.out.println(ir); assertEquals(ir.state,ItemState.APPROVED); tokenAtempt = token.createRevision(lenderKey); tokenAtempt.setOwnerKeys(TestKeys.publicKey(5)); tokenAtempt.seal(); ir = ts.client.register(tokenAtempt.getPackedTransaction(),8000); System.out.println(ir); assertEquals(ir.state,ItemState.APPROVED); collateralAtempt = collateral.createRevision(borrowerKey); collateralAtempt.setOwnerKeys(TestKeys.publicKey(5)); collateralAtempt.seal(); ir = ts.client.register(collateralAtempt.getPackedTransaction(),8000); System.out.println(ir); assertEquals(ir.state,ItemState.APPROVED); ts.shutdown(); }
public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); static final String NODE_VERSION; final Reporter reporter; final BufferedLogger logger; public NetConfig netConfig; public NetworkV2 network; final Config config; public NodeInfo myInfo; public Node node; public ItemCache cache; public ParcelCache parcelCache; public PaidOperationCache paidOperationCache; }
@Test public void secureLoanTestDefaultMintableSimple() throws Exception{ TestSpace ts = prepareTestSpace(); ts.nodes.forEach(n->n.config.setIsFreeRegistrationsAllowedFromYaml(true)); PrivateKey lenderKey = TestKeys.privateKey(1); PrivateKey borrowerKey = TestKeys.privateKey(2); KeyAddress lenderAddress = lenderKey.getPublicKey().getLongAddress(); KeyAddress borrowerAddress = borrowerKey.getPublicKey().getLongAddress(); Contract token = ContractsService.createMintableTokenContract(new HashSet<>(Do.listOf(TestKeys.privateKey(15))), new HashSet<>(Do.listOf(lenderKey.getPublicKey())), new BigDecimal("800"), new BigDecimal("0.1"), "uEUR", "UniEuro", "Coin description"); token.seal(); assertEquals(ts.client.register(token.getPackedTransaction(),8000).state,ItemState.APPROVED); Contract collateral = new Contract(borrowerKey); collateral.getStateData().put("description","This is very valuable contract"); collateral.seal(); assertEquals(ts.client.register(collateral.getPackedTransaction(),8000).state,ItemState.APPROVED); Contract[] res = SecureLoanHelper.initSecureLoan(new Binder(),lenderAddress, borrowerAddress, token, Duration.ofSeconds(3), collateral, "1000",true,null,token.getIssuer().getSimpleAddress(), (String) token.getDefinition().getData().get("currency")); Contract secureLoan = res[0]; Compound compound = new Compound(); compound.addContract("loan",secureLoan,null); compound.getCompoundContract().addSignatureToSeal(borrowerKey); compound.getCompoundContract().addSignatureToSeal(lenderKey); ItemResult ir = ts.client.register(compound.getCompoundContract().getPackedTransaction(), 8000); System.out.println(ir); assertEquals(ir.state,ItemState.APPROVED); Thread.sleep(6000); res = SecureLoanHelper.defaultSecureLoan(secureLoan); secureLoan = res[0]; compound = new Compound(); compound.addContract("loan",secureLoan,null); compound.getCompoundContract().addSignatureToSeal(lenderKey); collateral = res[1]; ir = ts.client.register(compound.getCompoundContract().getPackedTransaction(), 8000); System.out.println(ir); assertEquals(ir.state,ItemState.APPROVED); collateral = collateral.createRevision(lenderKey); collateral.setOwnerKeys(TestKeys.publicKey(5)); collateral.seal(); ir = ts.client.register(collateral.getPackedTransaction(), 8000); System.out.println(ir); assertEquals(ir.state,ItemState.APPROVED); ts.shutdown(); }
public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); static final String NODE_VERSION; final Reporter reporter; final BufferedLogger logger; public NetConfig netConfig; public NetworkV2 network; final Config config; public NodeInfo myInfo; public Node node; public ItemCache cache; public ParcelCache parcelCache; public PaidOperationCache paidOperationCache; }
@Test public void secureLoanTestRepaymentMintableSimple() throws Exception{ TestSpace ts = prepareTestSpace(); ts.nodes.forEach(n->n.config.setIsFreeRegistrationsAllowedFromYaml(true)); PrivateKey lenderKey = TestKeys.privateKey(1); PrivateKey borrowerKey = TestKeys.privateKey(2); KeyAddress lenderAddress = lenderKey.getPublicKey().getLongAddress(); KeyAddress borrowerAddress = borrowerKey.getPublicKey().getLongAddress(); Contract token = ContractsService.createMintableTokenContract(new HashSet<>(Do.listOf(TestKeys.privateKey(15))), new HashSet<>(Do.listOf(lenderKey.getPublicKey())), new BigDecimal("800"), new BigDecimal("0.1"), "uEUR", "UniEuro", "Coin description"); token.seal(); assertEquals(ts.client.register(token.getPackedTransaction(),8000).state,ItemState.APPROVED); Contract rest = ContractsService.createMintableTokenContract(new HashSet<>(Do.listOf(TestKeys.privateKey(15))), new HashSet<>(Do.listOf(borrowerKey.getPublicKey())), new BigDecimal("200"), new BigDecimal("0.1"), "uEUR", "UniEuro", "Coin description"); rest.seal(); assertEquals(ts.client.register(rest.getPackedTransaction(),8000).state,ItemState.APPROVED); Contract collateral = new Contract(borrowerKey); collateral.getStateData().put("description","This is very valuable contract"); collateral.seal(); assertEquals(ts.client.register(collateral.getPackedTransaction(),8000).state,ItemState.APPROVED); PrivateKey issuerKey = TestKeys.privateKey(13); Contract[] res = SecureLoanHelper.initSecureLoan(Do.listOf(issuerKey.getPublicKey().getLongAddress()),null, lenderAddress, borrowerAddress, token, Duration.ofSeconds(300), collateral, "1000",true,null,token.getIssuer().getSimpleAddress(), (String) token.getDefinition().getData().get("currency")); Contract secureLoan = res[0]; secureLoan.seal(); Compound compound = new Compound(); compound.addContract("loan",secureLoan,null); compound.getCompoundContract().addSignatureToSeal(borrowerKey); compound.getCompoundContract().addSignatureToSeal(lenderKey); compound.getCompoundContract().addSignatureToSeal(issuerKey); ItemResult ir = ts.client.register(compound.getCompoundContract().getPackedTransaction(), 8000); System.out.println(ir); assertEquals(ir.state,ItemState.APPROVED); token = res[1]; token = token.createRevision(borrowerKey); token.addRevokingItems(rest); token.getStateData().set("amount","1000"); token.seal(); ir = ts.client.register(token.getPackedTransaction(),8000); System.out.println(ir); assertEquals(ir.state,ItemState.APPROVED); res = SecureLoanHelper.repaySecureLoan(secureLoan,token); secureLoan = res[0]; compound = new Compound(); compound.addContract("loan",secureLoan,null); compound.getCompoundContract().addSignatureToSeal(borrowerKey); ir = ts.client.register(compound.getCompoundContract().getPackedTransaction(),8000); System.out.println(ir); assertEquals(ir.state,ItemState.APPROVED); res = SecureLoanHelper.closeSecureLoan(secureLoan); secureLoan = res[0]; token = res[1]; collateral = res[2]; compound = new Compound(); compound.addContract("loan",secureLoan,null); compound.getCompoundContract().addSignatureToSeal(borrowerKey); compound.getCompoundContract().addSignatureToSeal(lenderKey); ir = ts.client.register(compound.getCompoundContract().getPackedTransaction(),8000); System.out.println(ir); assertEquals(ir.state,ItemState.APPROVED); token = token.createRevision(lenderKey); token.setOwnerKeys(TestKeys.publicKey(5)); token.seal(); ir = ts.client.register(token.getPackedTransaction(),8000); System.out.println(ir); assertEquals(ir.state,ItemState.APPROVED); token = collateral.createRevision(borrowerKey); token.setOwnerKeys(TestKeys.publicKey(5)); token.seal(); ir = ts.client.register(token.getPackedTransaction(),8000); System.out.println(ir); assertEquals(ir.state,ItemState.APPROVED); ts.shutdown(); }
public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); static final String NODE_VERSION; final Reporter reporter; final BufferedLogger logger; public NetConfig netConfig; public NetworkV2 network; final Config config; public NodeInfo myInfo; public Node node; public ItemCache cache; public ParcelCache parcelCache; public PaidOperationCache paidOperationCache; }
@Test public void toHashWithDefaultData() throws Exception { AbstractPublicKey goodPublicKey1 = new RSAOAEPPublicKey( BigIntegers.asUnsignedByteArray(randomPublicKey1.getModulus()), BigIntegers.asUnsignedByteArray(randomPublicKey1.getExponent()), HashType.SHA1, HashType.SHA1, new SecureRandom()); Map map1 = goodPublicKey1.toHash(); assertArrayEquals((byte[]) map1.get("n"), BigIntegers.asUnsignedByteArray(randomPublicKey1.getModulus())); assertArrayEquals((byte[]) map1.get("e"), BigIntegers.asUnsignedByteArray(randomPublicKey1.getExponent())); assertFalse(map1.containsKey("hash")); assertFalse(map1.containsKey("mgf1Hash")); }
@NonNull @Override public Map<String, Object> toHash() throws IllegalStateException { if (state == null) { throw new IllegalStateException(); } else { return Collections.unmodifiableMap(new HashMap<String, Object>() {{ put("n", BigIntegers.asUnsignedByteArray(state.keyParameters.getModulus())); put("e", BigIntegers.asUnsignedByteArray(state.keyParameters.getExponent())); if (!state.mgf1HashType.equals(DEFAULT_MGF1_HASH)) { put("mgf1Hash", state.mgf1HashType.getAlgorithmName()); } }}); } }
RSAOAEPPublicKey extends AbstractPublicKey { @NonNull @Override public Map<String, Object> toHash() throws IllegalStateException { if (state == null) { throw new IllegalStateException(); } else { return Collections.unmodifiableMap(new HashMap<String, Object>() {{ put("n", BigIntegers.asUnsignedByteArray(state.keyParameters.getModulus())); put("e", BigIntegers.asUnsignedByteArray(state.keyParameters.getExponent())); if (!state.mgf1HashType.equals(DEFAULT_MGF1_HASH)) { put("mgf1Hash", state.mgf1HashType.getAlgorithmName()); } }}); } } }
RSAOAEPPublicKey extends AbstractPublicKey { @NonNull @Override public Map<String, Object> toHash() throws IllegalStateException { if (state == null) { throw new IllegalStateException(); } else { return Collections.unmodifiableMap(new HashMap<String, Object>() {{ put("n", BigIntegers.asUnsignedByteArray(state.keyParameters.getModulus())); put("e", BigIntegers.asUnsignedByteArray(state.keyParameters.getExponent())); if (!state.mgf1HashType.equals(DEFAULT_MGF1_HASH)) { put("mgf1Hash", state.mgf1HashType.getAlgorithmName()); } }}); } } RSAOAEPPublicKey(); RSAOAEPPublicKey(byte[] n, byte[] e, HashType oaepHashType, HashType mgf1HashType, SecureRandom rng); }
RSAOAEPPublicKey extends AbstractPublicKey { @NonNull @Override public Map<String, Object> toHash() throws IllegalStateException { if (state == null) { throw new IllegalStateException(); } else { return Collections.unmodifiableMap(new HashMap<String, Object>() {{ put("n", BigIntegers.asUnsignedByteArray(state.keyParameters.getModulus())); put("e", BigIntegers.asUnsignedByteArray(state.keyParameters.getExponent())); if (!state.mgf1HashType.equals(DEFAULT_MGF1_HASH)) { put("mgf1Hash", state.mgf1HashType.getAlgorithmName()); } }}); } } RSAOAEPPublicKey(); RSAOAEPPublicKey(byte[] n, byte[] e, HashType oaepHashType, HashType mgf1HashType, SecureRandom rng); @Override String toString(); @Override boolean canEncrypt(); @Override int getBitStrength(); @Override boolean isInitialized(); @NonNull @Override byte[] encrypt(byte[] plaintext); @NonNull @Override boolean checkSignature(InputStream input, byte[] signature, HashType hashType, int saltLength); @NonNull @Override String algorithmTag(); @NonNull @Override Map<String, Object> toHash(); @Override void updateFromHash(Map<String, Object> hash); }
RSAOAEPPublicKey extends AbstractPublicKey { @NonNull @Override public Map<String, Object> toHash() throws IllegalStateException { if (state == null) { throw new IllegalStateException(); } else { return Collections.unmodifiableMap(new HashMap<String, Object>() {{ put("n", BigIntegers.asUnsignedByteArray(state.keyParameters.getModulus())); put("e", BigIntegers.asUnsignedByteArray(state.keyParameters.getExponent())); if (!state.mgf1HashType.equals(DEFAULT_MGF1_HASH)) { put("mgf1Hash", state.mgf1HashType.getAlgorithmName()); } }}); } } RSAOAEPPublicKey(); RSAOAEPPublicKey(byte[] n, byte[] e, HashType oaepHashType, HashType mgf1HashType, SecureRandom rng); @Override String toString(); @Override boolean canEncrypt(); @Override int getBitStrength(); @Override boolean isInitialized(); @NonNull @Override byte[] encrypt(byte[] plaintext); @NonNull @Override boolean checkSignature(InputStream input, byte[] signature, HashType hashType, int saltLength); @NonNull @Override String algorithmTag(); @NonNull @Override Map<String, Object> toHash(); @Override void updateFromHash(Map<String, Object> hash); static final HashType DEFAULT_OAEP_HASH; static final HashType DEFAULT_MGF1_HASH; }
@Test public void testMainTopology() throws Exception { TestSpace ts = prepareTestSpace(); Client c = new Client("./src/test_node_config_v2/test_node_config_v2.json",System.getProperty("java.io.tmpdir"),TestKeys.privateKey(1)); System.out.println(c.getVersion()); ts.shutdown(); }
public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); static final String NODE_VERSION; final Reporter reporter; final BufferedLogger logger; public NetConfig netConfig; public NetworkV2 network; final Config config; public NodeInfo myInfo; public Node node; public ItemCache cache; public ParcelCache parcelCache; public PaidOperationCache paidOperationCache; }
@Test public void testReferencesToPermissionsAndCustomRoles() throws Exception { TestSpace ts = prepareTestSpace(); ts.nodes.forEach(n->n.config.setIsFreeRegistrationsAllowedFromYaml(true)); Client c = new Client("./src/test_node_config_v2/test_node_config_v2.json",System.getProperty("java.io.tmpdir"),ts.myKey); Contract contract = new Contract(TestKeys.privateKey(0)); Contract contract2 = new Contract(TestKeys.privateKey(0)); ChangeNumberPermission changeNumberPermission = new ChangeNumberPermission(new RoleLink("@owner", contract,"owner"), Binder.of( "field_name", "field1", "min_value", 33, "max_value", 34, "min_step", 1, "max_step", 1 ) ); ChangeNumberPermission changeNumberPermission2 = new ChangeNumberPermission(new RoleLink("@owner", contract2,"owner"), Binder.of( "field_name", "field1", "min_value", 33, "max_value", 34, "min_step", 1, "max_step", 1 ) ); changeNumberPermission.setId("changenumber"); changeNumberPermission2.setId("changenumber2"); contract.addRole(new RoleLink("link_to_issuer",contract,"issuer")); contract.addPermission(changeNumberPermission); contract2.addPermission(changeNumberPermission2); contract.seal(); Reference reference = new Reference(contract2); reference.name = "test1"; reference.setConditions(Binder.of("all_of", Do.listOf("ref.id==\""+contract.getId().toBase64String()+"\"","this.definition.permissions.changenumber2==ref.definition.permissions.changenumber"))); contract2.addReference(reference); contract2.addNewItems(contract); contract2.seal(); assertEquals(c.register(contract2.getPackedTransaction(),8000).state,ItemState.APPROVED); assertTrue(c.isApprovedByNetwork(contract2.getId(),0.9,8000)); ts.shutdown(); }
public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); static final String NODE_VERSION; final Reporter reporter; final BufferedLogger logger; public NetConfig netConfig; public NetworkV2 network; final Config config; public NodeInfo myInfo; public Node node; public ItemCache cache; public ParcelCache parcelCache; public PaidOperationCache paidOperationCache; }
@Test public void escrowHelperTest() throws Exception { KeyAddress issuerAddress = TestKeys.publicKey(9).getShortAddress(); KeyAddress contractorAddress = TestKeys.publicKey(10).getShortAddress(); KeyAddress customerAddress = TestKeys.publicKey(11).getShortAddress(); KeyAddress arbitratorAddress = TestKeys.publicKey(12).getShortAddress(); KeyAddress storageServiceAddress = TestKeys.publicKey(13).getShortAddress(); PrivateKey issuerKey = TestKeys.privateKey(9); PrivateKey contractorKey = TestKeys.privateKey(10); PrivateKey customerKey = TestKeys.privateKey(11); PrivateKey arbitratorKey = TestKeys.privateKey(12); PrivateKey storageServiceKey = TestKeys.privateKey(13); TestSpace ts = prepareTestSpace(); ts.nodes.forEach(n->{n.config.setIsFreeRegistrationsAllowedFromYaml(true); n.config.getAddressesWhiteList().add(ts.client.getSession().getPrivateKey().getPublicKey().getLongAddress());}); Contract payment; Contract escrow; ItemResult ir; Contract[] res; payment = new Contract(customerKey); payment.seal(); assertEquals(ts.client.register(payment.getPackedTransaction(),8000).state,ItemState.APPROVED); escrow = EscrowHelper.initEscrow(Do.listOf(issuerAddress),Binder.of("data","asdasd123"),Binder.of("description","This is description the work to be done"),customerAddress,arbitratorAddress,storageServiceAddress,Duration.ofDays(500),payment)[0]; escrow.addSignatureToSeal(issuerKey); escrow.addSignatureToSeal(customerKey); ir = ts.client.register(escrow.getPackedTransaction(),8000); System.out.println(ir); assertEquals(ir.state,ItemState.APPROVED); escrow = EscrowHelper.assignEscrow(escrow,contractorAddress,Binder.of("description","Assignment is done with additional info..."))[0]; escrow.addSignatureToSeal(customerKey); escrow.addSignatureToSeal(contractorKey); ir = ts.client.register(escrow.getPackedTransaction(), 8000); System.out.println(ir); assertEquals(ir.state,ItemState.APPROVED); escrow = EscrowHelper.completeEscrow(escrow,Binder.of("description","Completion details"))[0]; Compound compound = new Compound(); compound.addContract("escrow",escrow,null); compound.getCompoundContract().addSignatureToSeal(contractorKey); compound.getCompoundContract().addSignatureToSeal(storageServiceKey); ir = ts.client.register(compound.getCompoundContract().getPackedTransaction(), 8000); System.out.println(ir); assertEquals(ir.state,ItemState.APPROVED); escrow = compound.getContract("escrow"); res = EscrowHelper.closeByCustomer(escrow); escrow = res[0]; compound = new Compound(); compound.addContract("escrow",escrow,null); compound.getCompoundContract().addSignatureToSeal(customerKey); compound.getCompoundContract().addSignatureToSeal(storageServiceKey); ir = ts.client.register(compound.getCompoundContract().getPackedTransaction(), 8000); System.out.println(ir); assertEquals(ir.state,ItemState.APPROVED); escrow = compound.getContract("escrow"); res = EscrowHelper.obtainPaymentOnClosedEscrow(escrow); payment = res[0]; payment.addSignatureToSeal(contractorKey); ir = ts.client.register(payment.getPackedTransaction(), 8000); System.out.println(ir); assertEquals(ir.state,ItemState.APPROVED); payment = payment.createRevision(contractorKey); payment.setOwnerKeys(TestKeys.publicKey(20)); payment.seal(); ir = ts.client.register(payment.getPackedTransaction(), 8000); System.out.println(ir); assertEquals(ir.state,ItemState.APPROVED); payment = new Contract(customerKey); payment.seal(); assertEquals(ts.client.register(payment.getPackedTransaction(),8000).state,ItemState.APPROVED); escrow = EscrowHelper.initEscrow(Do.listOf(issuerAddress),null,Binder.of("description","This is description the work to be done"),customerAddress,arbitratorAddress,storageServiceAddress,Duration.ofDays(500),payment)[0]; escrow.addSignatureToSeal(customerKey); escrow.addSignatureToSeal(issuerKey); assertEquals(ts.client.register(escrow.getPackedTransaction(),8000).state,ItemState.APPROVED); escrow = EscrowHelper.assignEscrow(escrow,contractorAddress,Binder.of("description","Assignment is done with additional info..."))[0]; escrow.addSignatureToSeal(customerKey); escrow.addSignatureToSeal(contractorKey); ir = ts.client.register(escrow.getPackedTransaction(), 8000); System.out.println(ir); assertEquals(ir.state,ItemState.APPROVED); escrow = EscrowHelper.completeEscrow(escrow,Binder.of("description","Completion details"))[0]; escrow.addSignatureToSeal(contractorKey); escrow.addSignatureToSeal(storageServiceKey); ir = ts.client.register(escrow.getPackedTransaction(), 8000); System.out.println(ir); assertEquals(ir.state,ItemState.APPROVED); res = EscrowHelper.closeByArbitration(escrow); escrow = res[0]; escrow.addSignatureToSeal(arbitratorKey); escrow.addSignatureToSeal(contractorKey); escrow.addSignatureToSeal(storageServiceKey); ir = ts.client.register(escrow.getPackedTransaction(), 8000); System.out.println(ir); assertEquals(ir.state,ItemState.APPROVED); res = EscrowHelper.obtainPaymentOnClosedEscrow(escrow); payment = res[0]; payment.addSignatureToSeal(contractorKey); ir = ts.client.register(payment.getPackedTransaction(), 8000); System.out.println(ir); assertEquals(ir.state,ItemState.APPROVED); payment = payment.createRevision(contractorKey); payment.setOwnerKeys(TestKeys.publicKey(20)); payment.seal(); ir = ts.client.register(payment.getPackedTransaction(), 8000); System.out.println(ir); assertEquals(ir.state,ItemState.APPROVED); payment = new Contract(customerKey); payment.seal(); assertEquals(ts.client.register(payment.getPackedTransaction(),8000).state,ItemState.APPROVED); escrow = EscrowHelper.initEscrow(Do.listOf(issuerAddress),Binder.of("aaa","111"),Binder.of("description","This is description the work to be done"),customerAddress,arbitratorAddress,storageServiceAddress,Duration.ofDays(500),payment)[0]; escrow.addSignatureToSeal(customerKey); escrow.addSignatureToSeal(contractorKey); escrow.addSignatureToSeal(issuerKey); assertEquals(ts.client.register(escrow.getPackedTransaction(),8000).state,ItemState.APPROVED); escrow = EscrowHelper.assignEscrow(escrow,contractorAddress,Binder.of("description","Assignment is done with additional info..."))[0]; escrow.addSignatureToSeal(customerKey); escrow.addSignatureToSeal(contractorKey); ir = ts.client.register(escrow.getPackedTransaction(), 8000); System.out.println(ir); assertEquals(ir.state,ItemState.APPROVED); escrow = EscrowHelper.completeEscrow(escrow,Binder.of("description","Completion details"))[0]; escrow.addSignatureToSeal(contractorKey); escrow.addSignatureToSeal(storageServiceKey); ir = ts.client.register(escrow.getPackedTransaction(), 8000); System.out.println(ir); assertEquals(ir.state,ItemState.APPROVED); res = EscrowHelper.cancelEscrow(escrow); escrow = res[0]; escrow.addSignatureToSeal(customerKey); escrow.addSignatureToSeal(contractorKey); ir = ts.client.register(escrow.getPackedTransaction(), 8000); System.out.println(ir); assertEquals(ir.state,ItemState.APPROVED); payment = res[1]; payment = payment.createRevision(customerKey); payment.setOwnerKeys(TestKeys.publicKey(20)); payment.seal(); ir = ts.client.register(payment.getPackedTransaction(), 8000); System.out.println(ir); assertEquals(ir.state,ItemState.APPROVED); payment = new Contract(customerKey); payment.seal(); assertEquals(ts.client.register(payment.getPackedTransaction(),8000).state,ItemState.APPROVED); escrow = EscrowHelper.initEscrow(Do.listOf(issuerAddress),null,Binder.of("description","This is description the work to be done"),customerAddress,arbitratorAddress,storageServiceAddress,Duration.ofDays(500),payment)[0]; escrow.addSignatureToSeal(customerKey); escrow.addSignatureToSeal(issuerKey); assertEquals(ts.client.register(escrow.getPackedTransaction(),8000).state,ItemState.APPROVED); escrow = EscrowHelper.assignEscrow(escrow,contractorAddress,Binder.of("description","Assignment is done with additional info..."))[0]; escrow.addSignatureToSeal(customerKey); escrow.addSignatureToSeal(contractorKey); ir = ts.client.register(escrow.getPackedTransaction(), 8000); System.out.println(ir); assertEquals(ir.state,ItemState.APPROVED); escrow = EscrowHelper.completeEscrow(escrow,Binder.of("description","Completion details"))[0]; escrow.addSignatureToSeal(contractorKey); escrow.addSignatureToSeal(storageServiceKey); ir = ts.client.register(escrow.getPackedTransaction(), 8000); System.out.println(ir); assertEquals(ir.state,ItemState.APPROVED); res = EscrowHelper.cancelEscrow(escrow); escrow = res[0]; escrow.addSignatureToSeal(arbitratorKey); escrow.addSignatureToSeal(customerKey); escrow.addSignatureToSeal(storageServiceKey); ir = ts.client.register(escrow.getPackedTransaction(), 8000); System.out.println(ir); assertEquals(ir.state,ItemState.APPROVED); payment = res[1]; payment = payment.createRevision(customerKey); payment.setOwnerKeys(TestKeys.publicKey(20)); payment.seal(); ir = ts.client.register(payment.getPackedTransaction(), 8000); System.out.println(ir); assertEquals(ir.state,ItemState.APPROVED); payment = new Contract(customerKey); payment.seal(); assertEquals(ts.client.register(payment.getPackedTransaction(),8000).state,ItemState.APPROVED); escrow = EscrowHelper.initEscrow(Do.listOf(issuerAddress),null,Binder.of("description","This is description the work to be done"),customerAddress,arbitratorAddress,storageServiceAddress,Duration.ofDays(500),payment)[0]; escrow.addSignatureToSeal(customerKey); escrow.addSignatureToSeal(issuerKey); assertEquals(ts.client.register(escrow.getPackedTransaction(),8000).state,ItemState.APPROVED); escrow = EscrowHelper.assignEscrow(escrow,contractorAddress,Binder.of("description","Assignment is done with additional info..."))[0]; escrow.addSignatureToSeal(customerKey); escrow.addSignatureToSeal(contractorKey); ir = ts.client.register(escrow.getPackedTransaction(), 8000); System.out.println(ir); assertEquals(ir.state,ItemState.APPROVED); res = EscrowHelper.cancelEscrow(escrow); escrow = res[0]; escrow.addSignatureToSeal(contractorKey); escrow.addSignatureToSeal(customerKey); ir = ts.client.register(escrow.getPackedTransaction(), 8000); System.out.println(ir); assertEquals(ir.state,ItemState.APPROVED); payment = res[1]; payment = payment.createRevision(customerKey); payment.setOwnerKeys(TestKeys.publicKey(20)); payment.seal(); payment.getTransactionPack().addReferencedItem(escrow); ir = ts.client.register(payment.getPackedTransaction(), 8000); System.out.println(ir); assertEquals(ir.state,ItemState.APPROVED); payment = new Contract(customerKey); payment.seal(); assertEquals(ts.client.register(payment.getPackedTransaction(),8000).state,ItemState.APPROVED); escrow = EscrowHelper.initEscrow(Do.listOf(issuerAddress),null,Binder.of("description","This is description the work to be done"),customerAddress,arbitratorAddress,storageServiceAddress,Duration.ofSeconds(3),payment)[0]; escrow.addSignatureToSeal(customerKey); escrow.addSignatureToSeal(issuerKey); assertEquals(ts.client.register(escrow.getPackedTransaction(),8000).state,ItemState.APPROVED); escrow = EscrowHelper.assignEscrow(escrow,contractorAddress,Binder.of("description","Assignment is done with additional info..."))[0]; escrow.addSignatureToSeal(customerKey); escrow.addSignatureToSeal(contractorKey); ir = ts.client.register(escrow.getPackedTransaction(), 8000); System.out.println(ir); assertEquals(ir.state,ItemState.APPROVED); Thread.sleep(3000); res = EscrowHelper.cancelEscrow(escrow); escrow = res[0]; escrow.addSignatureToSeal(customerKey); ir = ts.client.register(escrow.getPackedTransaction(), 8000); System.out.println(ir); assertEquals(ir.state,ItemState.APPROVED); payment = res[1]; payment = payment.createRevision(customerKey); payment.setOwnerKeys(TestKeys.publicKey(20)); payment.seal(); ir = ts.client.register(payment.getPackedTransaction(), 8000); System.out.println(ir); assertEquals(ir.state,ItemState.APPROVED); payment = new Contract(customerKey); payment.seal(); assertEquals(ts.client.register(payment.getPackedTransaction(),8000).state,ItemState.APPROVED); escrow = EscrowHelper.initEscrow(Do.listOf(issuerAddress),null,Binder.of("description","This is description the work to be done"),customerAddress,arbitratorAddress,storageServiceAddress,Duration.ofSeconds(30000),payment)[0]; escrow.addSignatureToSeal(customerKey); escrow.addSignatureToSeal(issuerKey); assertEquals(ts.client.register(escrow.getPackedTransaction(),8000).state,ItemState.APPROVED); res = EscrowHelper.cancelEscrow(escrow); escrow = res[0]; escrow.addSignatureToSeal(customerKey); ir = ts.client.register(escrow.getPackedTransaction(), 8000); System.out.println(ir); assertEquals(ir.state,ItemState.APPROVED); payment = res[1]; payment = payment.createRevision(customerKey); payment.setOwnerKeys(TestKeys.publicKey(20)); payment.seal(); ir = ts.client.register(payment.getPackedTransaction(), 8000); System.out.println(ir); assertEquals(ir.state,ItemState.APPROVED); ts.shutdown(); }
public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); static final String NODE_VERSION; final Reporter reporter; final BufferedLogger logger; public NetConfig netConfig; public NetworkV2 network; final Config config; public NodeInfo myInfo; public Node node; public ItemCache cache; public ParcelCache parcelCache; public PaidOperationCache paidOperationCache; }
@Test public void errorsFromParcel() throws Exception { TestSpace ts = prepareTestSpace(); ts.nodes.forEach(n->n.config.setIsFreeRegistrationsAllowedFromYaml(true)); Contract contract = new Contract(TestKeys.privateKey(1)); contract.setIssuerKeys(TestKeys.privateKey(1).getPublicKey().getLongAddress()); contract.setOwnerKeys(TestKeys.privateKey(1).getPublicKey().getLongAddress()); contract.seal(); assertEquals(ts.client.register(contract.getPackedTransaction(),8000).state,ItemState.APPROVED); contract = contract.createRevision(TestKeys.privateKey(2)); contract.setOwnerKeys(TestKeys.privateKey(2)); contract.seal(); contract.check(); Contract u = getApprovedUContract(ts); Parcel p = ContractsService.createParcel(contract,u,contract.getProcessedCostU(),ts.getUKeys()); ItemResult ir = ts.client.registerParcelWithState(p.pack(), 8000); assertEquals(ir.state,ItemState.DECLINED); assertEquals(ir.errors.size(),contract.getErrors().size()); ts.shutdown(); }
public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); }
Main { public void shutdown() { try { if (hookThread != null) Runtime.getRuntime().removeShutdownHook(hookThread); ledger.close(); log("shutting down"); network.shutdown(); clientHTTPServer.shutdown(); } catch (Exception e) { } synchronized (parser) { parser.notifyAll(); } try { logger.close(); } catch (Exception e) { e.printStackTrace(); } } Main(String[] args); static void main(String[] args); void waitReady(); void shutdown(); void setVerboseLevel(int level); void setUDPVerboseLevel(int level); void restartUDPAdapter(); PublicKey getNodePublicKey(); static final String NODE_VERSION; final Reporter reporter; final BufferedLogger logger; public NetConfig netConfig; public NetworkV2 network; final Config config; public NodeInfo myInfo; public Node node; public ItemCache cache; public ParcelCache parcelCache; public PaidOperationCache paidOperationCache; }
@Test public void cleanUp() throws Exception { ItemCache c = new ItemCache(Duration.ofMillis(10)); TestItem i1 = new TestItem(true); c.put(i1, ItemResult.UNDEFINED); assertEquals(i1, c.get(i1.getId())); Thread.sleep(11); c.cleanUp(); assertEquals(null, c.get(i1.getId())); }
final void cleanUp() { Instant now = Instant.now(); records.values().forEach(r->r.checkExpiration(now)); }
ItemCache { final void cleanUp() { Instant now = Instant.now(); records.values().forEach(r->r.checkExpiration(now)); } }
ItemCache { final void cleanUp() { Instant now = Instant.now(); records.values().forEach(r->r.checkExpiration(now)); } ItemCache(Duration maxAge); }
ItemCache { final void cleanUp() { Instant now = Instant.now(); records.values().forEach(r->r.checkExpiration(now)); } ItemCache(Duration maxAge); void shutdown(); @Nullable Approvable get(HashId itemId); @Nullable ItemResult getResult(HashId itemId); void put(Approvable item, ItemResult result); void update(HashId itemId, ItemResult result); void idsCheck(HashId itemId); int size(); }
ItemCache { final void cleanUp() { Instant now = Instant.now(); records.values().forEach(r->r.checkExpiration(now)); } ItemCache(Duration maxAge); void shutdown(); @Nullable Approvable get(HashId itemId); @Nullable ItemResult getResult(HashId itemId); void put(Approvable item, ItemResult result); void update(HashId itemId, ItemResult result); void idsCheck(HashId itemId); int size(); }
@Test public void createOutputLockRecord() throws Exception { ledger.enableCache(true); StateRecord owner = ledger.findOrCreate(HashId.createRandom()); StateRecord other = ledger.findOrCreate(HashId.createRandom()); HashId id = HashId.createRandom(); StateRecord r1 = owner.createOutputLockRecord(id); r1.reload(); assertEquals(id, r1.getId()); assertEquals(ItemState.LOCKED_FOR_CREATION, r1.getState()); assertEquals(owner.getRecordId(), r1.getLockedByRecordId()); StateRecord r2 = owner.createOutputLockRecord(id); assertNull(r2); assertNull(owner.createOutputLockRecord(other.getId())); assertNull(ledger.createOutputLockRecord(owner.getRecordId(), other.getId())); }
@Override public StateRecord createOutputLockRecord(long creatorRecordId, HashId newItemHashId) { StateRecord r = new StateRecord(this); r.setState(ItemState.LOCKED_FOR_CREATION); r.setLockedByRecordId(creatorRecordId); r.setId(newItemHashId); try { r.save(); return r; } catch (Failure e) { e.printStackTrace(); return null; } catch (Exception e) { e.printStackTrace(); return null; } }
PostgresLedger implements Ledger { @Override public StateRecord createOutputLockRecord(long creatorRecordId, HashId newItemHashId) { StateRecord r = new StateRecord(this); r.setState(ItemState.LOCKED_FOR_CREATION); r.setLockedByRecordId(creatorRecordId); r.setId(newItemHashId); try { r.save(); return r; } catch (Failure e) { e.printStackTrace(); return null; } catch (Exception e) { e.printStackTrace(); return null; } } }
PostgresLedger implements Ledger { @Override public StateRecord createOutputLockRecord(long creatorRecordId, HashId newItemHashId) { StateRecord r = new StateRecord(this); r.setState(ItemState.LOCKED_FOR_CREATION); r.setLockedByRecordId(creatorRecordId); r.setId(newItemHashId); try { r.save(); return r; } catch (Failure e) { e.printStackTrace(); return null; } catch (Exception e) { e.printStackTrace(); return null; } } PostgresLedger(String connectionString, Properties properties); PostgresLedger(String connectionString); }
PostgresLedger implements Ledger { @Override public StateRecord createOutputLockRecord(long creatorRecordId, HashId newItemHashId) { StateRecord r = new StateRecord(this); r.setState(ItemState.LOCKED_FOR_CREATION); r.setLockedByRecordId(creatorRecordId); r.setId(newItemHashId); try { r.save(); return r; } catch (Failure e) { e.printStackTrace(); return null; } catch (Exception e) { e.printStackTrace(); return null; } } PostgresLedger(String connectionString, Properties properties); PostgresLedger(String connectionString); final T inPool(DbPool.DbConsumer<T> consumer); @Override StateRecord getRecord(HashId itemId); @Override StateRecord createOutputLockRecord(long creatorRecordId, HashId newItemHashId); @Override StateRecord getLockOwnerOf(StateRecord rc); @Override StateRecord findOrCreate(HashId itemId); @Override Map<HashId,StateRecord> findUnfinished(); @Override Approvable getItem(final StateRecord record); @Override void putItem(StateRecord record, Approvable item, Instant keepTill); @Override byte[] getKeepingItem(HashId itemId); @Override @Deprecated Object getKeepingByOrigin(HashId origin, int limit); @Override Binder getKeepingBy(String field, HashId id, Binder tags, int limit, int offset, String sortBy, String sortOrder); @Override void putKeepingItem(StateRecord record, Approvable item); @Override void close(); @Override long countRecords(); @Override Map<ItemState, Integer> getLedgerSize(ZonedDateTime createdAfter); @Override T transaction(Callable<T> callable); void testClearLedger(); @Override void destroy(StateRecord record); @Override void markTestRecord(HashId hash); @Override boolean isTestnet(HashId itemId); @Override void save(StateRecord stateRecord); @Override void reload(StateRecord stateRecord); void enableCache(boolean enable); Db getDb(); @Override void saveConfig(NodeInfo myInfo, NetConfig netConfig, PrivateKey nodeKey); @Override Object[] loadConfig(); @Override void addNode(NodeInfo nodeInfo); @Override void removeNode(NodeInfo nodeInfo); void cleanup(boolean isPermanetMode); void savePayment(int amount, ZonedDateTime date); Map<Integer,Integer> getPayments(ZonedDateTime fromDate); @Override NImmutableEnvironment getEnvironment(long environmentId); @Override NImmutableEnvironment getEnvironment(HashId contractId); @Override NImmutableEnvironment getEnvironment(NSmartContract smartContract); @Override void updateSubscriptionInStorage(long subscriptionId, ZonedDateTime expiresAt); @Override void updateStorageExpiresAt(long storageId, ZonedDateTime expiresAt); @Override void saveFollowerEnvironment(long environmentId, ZonedDateTime expiresAt, ZonedDateTime mutedAt, double spent, int startedCallbacks); @Override void updateNameRecord(long nameRecordId, ZonedDateTime expiresAt); @Override Set<HashId> saveEnvironment(NImmutableEnvironment environment); @Override Set<HashId> findBadReferencesOf(Set<HashId> ids); @Override long saveSubscriptionInStorage(HashId hashId, boolean subscriptionOnChain, ZonedDateTime expiresAt, long environmentId); @Override void clearExpiredSubscriptions(); @Override void clearExpiredStorages(); @Override void clearExpiredStorageContractBinaries(); @Override void updateEnvironment(long id, String ncontractType, HashId ncontractHashId, byte[] kvStorage, byte[] transactionPack); @Override Set<Long> getSubscriptionEnviromentIds(HashId id); @Override NCallbackService.FollowerCallbackState getFollowerCallbackStateById(HashId id); @Override Collection<CallbackRecord> getFollowerCallbacksToResyncByEnvId(long environmentId); @Override Collection<CallbackRecord> getFollowerCallbacksToResync(); @Override void addFollowerCallback(HashId id, long environmentId, ZonedDateTime expiresAt, ZonedDateTime storedUntil); @Override void updateFollowerCallbackState(HashId id, NCallbackService.FollowerCallbackState state); @Override void removeFollowerCallback(HashId id); @Override byte[] getSmartContractById(HashId smartContractId); @Override byte[] getContractInStorage(HashId contractId); @Override byte[] getContractInStorage(HashId slotId, HashId contractId); @Override List<byte[]> getContractsInStorageByOrigin(HashId slotId, HashId originId); @Override void removeEnvironmentSubscription(long subscriptionId); @Override void removeEnvironmentStorage(long storageId); @Override long removeEnvironment(HashId ncontractHashId); long getEnvironmentId(HashId ncontractHashId); void removeSubscriptionsByEnvId(long environmentId); void removeStorageContractsByEnvId(long environmentId); @Override void removeExpiredStoragesAndSubscriptionsCascade(); @Override void addNameRecord(final NNameRecord nameRecord); @Override long saveContractInStorage(HashId contractId, byte[] binData, ZonedDateTime expiresAt, HashId origin, long environmentId); @Override void removeNameRecord(NNameRecord nameRecord); @Override void addNameRecordEntry(final NNameRecordEntry nameRecordEntryModel); @Override void removeNameRecordEntry(NNameRecordEntry nameRecordEntry); @Override List<String> isAllNameRecordsAvailable(final Collection<String> reducedNames); @Override List<String> isAllOriginsAvailable(final Collection<HashId> origins); @Override List<String> isAllAddressesAvailable(final Collection<String> addresses); void clearExpiredNameRecords(Duration holdDuration); @Override @Deprecated NNameRecord getNameRecord(final String name); @Override Set<NNameRecord> getNameRecords(final String name); @Override List<NNameRecordEntry> getNameEntries(final long environmentId); @Override @Deprecated List<NNameRecordEntry> getNameEntries(final String nameReduced); @Override List<NNameRecord> getNamesByAddress(String address); @Override List<NNameRecord> getNamesByOrigin(byte[] origin); @Override VoteInfo initiateVoting(Contract contract, ZonedDateTime expiresAt, String roleName, Set<HashId> candidates); @Override VoteInfo getVotingInfo(HashId votingItem); @Override void addVotes(long votingId, long candidateId, List<KeyAddress> votes); @Override List<VoteResult> getVotes(HashId itemId, boolean queryAddresses); @Override void closeVote(HashId itemId); @Override void saveUbotSession(UbotSessionCompact sessionCompact); void saveUbotStorages(HashId executableContractId, ZonedDateTime expiresAt, Map<String, HashId> storages); @Override void saveUbotStorageValue(HashId executableContractId, ZonedDateTime expiresAt, String storageName, HashId value); @Override HashId getUbotStorageValue(HashId executableContractId, String storageName); @Override void getUbotStorages(HashId executableContractId, Map<String, HashId> dest); @Override UbotSessionCompact loadUbotSession(HashId executableContractId); @Override UbotSessionCompact loadUbotSessionByRequestId(HashId requestId); @Override UbotSessionCompact loadUbotSessionById(HashId sessionId); @Override boolean hasUbotSession(HashId executableContractId); @Override void deleteUbotSession(HashId executableContractId); @Override void deleteExpiredUbotSessions(); @Override void deleteExpiredUbotStorages(); @Override void saveUbotTransaction(HashId executableContractId, String transactionName, Binder state); @Override Binder loadUbotTransaction(HashId executableContractId, String transactionName); }
PostgresLedger implements Ledger { @Override public StateRecord createOutputLockRecord(long creatorRecordId, HashId newItemHashId) { StateRecord r = new StateRecord(this); r.setState(ItemState.LOCKED_FOR_CREATION); r.setLockedByRecordId(creatorRecordId); r.setId(newItemHashId); try { r.save(); return r; } catch (Failure e) { e.printStackTrace(); return null; } catch (Exception e) { e.printStackTrace(); return null; } } PostgresLedger(String connectionString, Properties properties); PostgresLedger(String connectionString); final T inPool(DbPool.DbConsumer<T> consumer); @Override StateRecord getRecord(HashId itemId); @Override StateRecord createOutputLockRecord(long creatorRecordId, HashId newItemHashId); @Override StateRecord getLockOwnerOf(StateRecord rc); @Override StateRecord findOrCreate(HashId itemId); @Override Map<HashId,StateRecord> findUnfinished(); @Override Approvable getItem(final StateRecord record); @Override void putItem(StateRecord record, Approvable item, Instant keepTill); @Override byte[] getKeepingItem(HashId itemId); @Override @Deprecated Object getKeepingByOrigin(HashId origin, int limit); @Override Binder getKeepingBy(String field, HashId id, Binder tags, int limit, int offset, String sortBy, String sortOrder); @Override void putKeepingItem(StateRecord record, Approvable item); @Override void close(); @Override long countRecords(); @Override Map<ItemState, Integer> getLedgerSize(ZonedDateTime createdAfter); @Override T transaction(Callable<T> callable); void testClearLedger(); @Override void destroy(StateRecord record); @Override void markTestRecord(HashId hash); @Override boolean isTestnet(HashId itemId); @Override void save(StateRecord stateRecord); @Override void reload(StateRecord stateRecord); void enableCache(boolean enable); Db getDb(); @Override void saveConfig(NodeInfo myInfo, NetConfig netConfig, PrivateKey nodeKey); @Override Object[] loadConfig(); @Override void addNode(NodeInfo nodeInfo); @Override void removeNode(NodeInfo nodeInfo); void cleanup(boolean isPermanetMode); void savePayment(int amount, ZonedDateTime date); Map<Integer,Integer> getPayments(ZonedDateTime fromDate); @Override NImmutableEnvironment getEnvironment(long environmentId); @Override NImmutableEnvironment getEnvironment(HashId contractId); @Override NImmutableEnvironment getEnvironment(NSmartContract smartContract); @Override void updateSubscriptionInStorage(long subscriptionId, ZonedDateTime expiresAt); @Override void updateStorageExpiresAt(long storageId, ZonedDateTime expiresAt); @Override void saveFollowerEnvironment(long environmentId, ZonedDateTime expiresAt, ZonedDateTime mutedAt, double spent, int startedCallbacks); @Override void updateNameRecord(long nameRecordId, ZonedDateTime expiresAt); @Override Set<HashId> saveEnvironment(NImmutableEnvironment environment); @Override Set<HashId> findBadReferencesOf(Set<HashId> ids); @Override long saveSubscriptionInStorage(HashId hashId, boolean subscriptionOnChain, ZonedDateTime expiresAt, long environmentId); @Override void clearExpiredSubscriptions(); @Override void clearExpiredStorages(); @Override void clearExpiredStorageContractBinaries(); @Override void updateEnvironment(long id, String ncontractType, HashId ncontractHashId, byte[] kvStorage, byte[] transactionPack); @Override Set<Long> getSubscriptionEnviromentIds(HashId id); @Override NCallbackService.FollowerCallbackState getFollowerCallbackStateById(HashId id); @Override Collection<CallbackRecord> getFollowerCallbacksToResyncByEnvId(long environmentId); @Override Collection<CallbackRecord> getFollowerCallbacksToResync(); @Override void addFollowerCallback(HashId id, long environmentId, ZonedDateTime expiresAt, ZonedDateTime storedUntil); @Override void updateFollowerCallbackState(HashId id, NCallbackService.FollowerCallbackState state); @Override void removeFollowerCallback(HashId id); @Override byte[] getSmartContractById(HashId smartContractId); @Override byte[] getContractInStorage(HashId contractId); @Override byte[] getContractInStorage(HashId slotId, HashId contractId); @Override List<byte[]> getContractsInStorageByOrigin(HashId slotId, HashId originId); @Override void removeEnvironmentSubscription(long subscriptionId); @Override void removeEnvironmentStorage(long storageId); @Override long removeEnvironment(HashId ncontractHashId); long getEnvironmentId(HashId ncontractHashId); void removeSubscriptionsByEnvId(long environmentId); void removeStorageContractsByEnvId(long environmentId); @Override void removeExpiredStoragesAndSubscriptionsCascade(); @Override void addNameRecord(final NNameRecord nameRecord); @Override long saveContractInStorage(HashId contractId, byte[] binData, ZonedDateTime expiresAt, HashId origin, long environmentId); @Override void removeNameRecord(NNameRecord nameRecord); @Override void addNameRecordEntry(final NNameRecordEntry nameRecordEntryModel); @Override void removeNameRecordEntry(NNameRecordEntry nameRecordEntry); @Override List<String> isAllNameRecordsAvailable(final Collection<String> reducedNames); @Override List<String> isAllOriginsAvailable(final Collection<HashId> origins); @Override List<String> isAllAddressesAvailable(final Collection<String> addresses); void clearExpiredNameRecords(Duration holdDuration); @Override @Deprecated NNameRecord getNameRecord(final String name); @Override Set<NNameRecord> getNameRecords(final String name); @Override List<NNameRecordEntry> getNameEntries(final long environmentId); @Override @Deprecated List<NNameRecordEntry> getNameEntries(final String nameReduced); @Override List<NNameRecord> getNamesByAddress(String address); @Override List<NNameRecord> getNamesByOrigin(byte[] origin); @Override VoteInfo initiateVoting(Contract contract, ZonedDateTime expiresAt, String roleName, Set<HashId> candidates); @Override VoteInfo getVotingInfo(HashId votingItem); @Override void addVotes(long votingId, long candidateId, List<KeyAddress> votes); @Override List<VoteResult> getVotes(HashId itemId, boolean queryAddresses); @Override void closeVote(HashId itemId); @Override void saveUbotSession(UbotSessionCompact sessionCompact); void saveUbotStorages(HashId executableContractId, ZonedDateTime expiresAt, Map<String, HashId> storages); @Override void saveUbotStorageValue(HashId executableContractId, ZonedDateTime expiresAt, String storageName, HashId value); @Override HashId getUbotStorageValue(HashId executableContractId, String storageName); @Override void getUbotStorages(HashId executableContractId, Map<String, HashId> dest); @Override UbotSessionCompact loadUbotSession(HashId executableContractId); @Override UbotSessionCompact loadUbotSessionByRequestId(HashId requestId); @Override UbotSessionCompact loadUbotSessionById(HashId sessionId); @Override boolean hasUbotSession(HashId executableContractId); @Override void deleteUbotSession(HashId executableContractId); @Override void deleteExpiredUbotSessions(); @Override void deleteExpiredUbotStorages(); @Override void saveUbotTransaction(HashId executableContractId, String transactionName, Binder state); @Override Binder loadUbotTransaction(HashId executableContractId, String transactionName); final static String SEARCH_TAGS; }
@Test public void destroy() throws Exception { StateRecord r1 = ledger.findOrCreate(HashId.createRandom()); r1.destroy(); assertNull(ledger.getRecord(r1.getId())); }
@Override public void destroy(StateRecord record) { long recordId = record.getRecordId(); if (recordId == 0) { throw new IllegalStateException("can't destroy record without recordId"); } protect(() -> { inPool(d -> { d.update("DELETE FROM ledger WHERE id = ?", recordId); return null; }); synchronized (cachedRecords) { cachedRecords.remove(record.getId()); } synchronized (cachedRecordsById) { cachedRecordsById.remove(record.getRecordId()); } return null; }); }
PostgresLedger implements Ledger { @Override public void destroy(StateRecord record) { long recordId = record.getRecordId(); if (recordId == 0) { throw new IllegalStateException("can't destroy record without recordId"); } protect(() -> { inPool(d -> { d.update("DELETE FROM ledger WHERE id = ?", recordId); return null; }); synchronized (cachedRecords) { cachedRecords.remove(record.getId()); } synchronized (cachedRecordsById) { cachedRecordsById.remove(record.getRecordId()); } return null; }); } }
PostgresLedger implements Ledger { @Override public void destroy(StateRecord record) { long recordId = record.getRecordId(); if (recordId == 0) { throw new IllegalStateException("can't destroy record without recordId"); } protect(() -> { inPool(d -> { d.update("DELETE FROM ledger WHERE id = ?", recordId); return null; }); synchronized (cachedRecords) { cachedRecords.remove(record.getId()); } synchronized (cachedRecordsById) { cachedRecordsById.remove(record.getRecordId()); } return null; }); } PostgresLedger(String connectionString, Properties properties); PostgresLedger(String connectionString); }
PostgresLedger implements Ledger { @Override public void destroy(StateRecord record) { long recordId = record.getRecordId(); if (recordId == 0) { throw new IllegalStateException("can't destroy record without recordId"); } protect(() -> { inPool(d -> { d.update("DELETE FROM ledger WHERE id = ?", recordId); return null; }); synchronized (cachedRecords) { cachedRecords.remove(record.getId()); } synchronized (cachedRecordsById) { cachedRecordsById.remove(record.getRecordId()); } return null; }); } PostgresLedger(String connectionString, Properties properties); PostgresLedger(String connectionString); final T inPool(DbPool.DbConsumer<T> consumer); @Override StateRecord getRecord(HashId itemId); @Override StateRecord createOutputLockRecord(long creatorRecordId, HashId newItemHashId); @Override StateRecord getLockOwnerOf(StateRecord rc); @Override StateRecord findOrCreate(HashId itemId); @Override Map<HashId,StateRecord> findUnfinished(); @Override Approvable getItem(final StateRecord record); @Override void putItem(StateRecord record, Approvable item, Instant keepTill); @Override byte[] getKeepingItem(HashId itemId); @Override @Deprecated Object getKeepingByOrigin(HashId origin, int limit); @Override Binder getKeepingBy(String field, HashId id, Binder tags, int limit, int offset, String sortBy, String sortOrder); @Override void putKeepingItem(StateRecord record, Approvable item); @Override void close(); @Override long countRecords(); @Override Map<ItemState, Integer> getLedgerSize(ZonedDateTime createdAfter); @Override T transaction(Callable<T> callable); void testClearLedger(); @Override void destroy(StateRecord record); @Override void markTestRecord(HashId hash); @Override boolean isTestnet(HashId itemId); @Override void save(StateRecord stateRecord); @Override void reload(StateRecord stateRecord); void enableCache(boolean enable); Db getDb(); @Override void saveConfig(NodeInfo myInfo, NetConfig netConfig, PrivateKey nodeKey); @Override Object[] loadConfig(); @Override void addNode(NodeInfo nodeInfo); @Override void removeNode(NodeInfo nodeInfo); void cleanup(boolean isPermanetMode); void savePayment(int amount, ZonedDateTime date); Map<Integer,Integer> getPayments(ZonedDateTime fromDate); @Override NImmutableEnvironment getEnvironment(long environmentId); @Override NImmutableEnvironment getEnvironment(HashId contractId); @Override NImmutableEnvironment getEnvironment(NSmartContract smartContract); @Override void updateSubscriptionInStorage(long subscriptionId, ZonedDateTime expiresAt); @Override void updateStorageExpiresAt(long storageId, ZonedDateTime expiresAt); @Override void saveFollowerEnvironment(long environmentId, ZonedDateTime expiresAt, ZonedDateTime mutedAt, double spent, int startedCallbacks); @Override void updateNameRecord(long nameRecordId, ZonedDateTime expiresAt); @Override Set<HashId> saveEnvironment(NImmutableEnvironment environment); @Override Set<HashId> findBadReferencesOf(Set<HashId> ids); @Override long saveSubscriptionInStorage(HashId hashId, boolean subscriptionOnChain, ZonedDateTime expiresAt, long environmentId); @Override void clearExpiredSubscriptions(); @Override void clearExpiredStorages(); @Override void clearExpiredStorageContractBinaries(); @Override void updateEnvironment(long id, String ncontractType, HashId ncontractHashId, byte[] kvStorage, byte[] transactionPack); @Override Set<Long> getSubscriptionEnviromentIds(HashId id); @Override NCallbackService.FollowerCallbackState getFollowerCallbackStateById(HashId id); @Override Collection<CallbackRecord> getFollowerCallbacksToResyncByEnvId(long environmentId); @Override Collection<CallbackRecord> getFollowerCallbacksToResync(); @Override void addFollowerCallback(HashId id, long environmentId, ZonedDateTime expiresAt, ZonedDateTime storedUntil); @Override void updateFollowerCallbackState(HashId id, NCallbackService.FollowerCallbackState state); @Override void removeFollowerCallback(HashId id); @Override byte[] getSmartContractById(HashId smartContractId); @Override byte[] getContractInStorage(HashId contractId); @Override byte[] getContractInStorage(HashId slotId, HashId contractId); @Override List<byte[]> getContractsInStorageByOrigin(HashId slotId, HashId originId); @Override void removeEnvironmentSubscription(long subscriptionId); @Override void removeEnvironmentStorage(long storageId); @Override long removeEnvironment(HashId ncontractHashId); long getEnvironmentId(HashId ncontractHashId); void removeSubscriptionsByEnvId(long environmentId); void removeStorageContractsByEnvId(long environmentId); @Override void removeExpiredStoragesAndSubscriptionsCascade(); @Override void addNameRecord(final NNameRecord nameRecord); @Override long saveContractInStorage(HashId contractId, byte[] binData, ZonedDateTime expiresAt, HashId origin, long environmentId); @Override void removeNameRecord(NNameRecord nameRecord); @Override void addNameRecordEntry(final NNameRecordEntry nameRecordEntryModel); @Override void removeNameRecordEntry(NNameRecordEntry nameRecordEntry); @Override List<String> isAllNameRecordsAvailable(final Collection<String> reducedNames); @Override List<String> isAllOriginsAvailable(final Collection<HashId> origins); @Override List<String> isAllAddressesAvailable(final Collection<String> addresses); void clearExpiredNameRecords(Duration holdDuration); @Override @Deprecated NNameRecord getNameRecord(final String name); @Override Set<NNameRecord> getNameRecords(final String name); @Override List<NNameRecordEntry> getNameEntries(final long environmentId); @Override @Deprecated List<NNameRecordEntry> getNameEntries(final String nameReduced); @Override List<NNameRecord> getNamesByAddress(String address); @Override List<NNameRecord> getNamesByOrigin(byte[] origin); @Override VoteInfo initiateVoting(Contract contract, ZonedDateTime expiresAt, String roleName, Set<HashId> candidates); @Override VoteInfo getVotingInfo(HashId votingItem); @Override void addVotes(long votingId, long candidateId, List<KeyAddress> votes); @Override List<VoteResult> getVotes(HashId itemId, boolean queryAddresses); @Override void closeVote(HashId itemId); @Override void saveUbotSession(UbotSessionCompact sessionCompact); void saveUbotStorages(HashId executableContractId, ZonedDateTime expiresAt, Map<String, HashId> storages); @Override void saveUbotStorageValue(HashId executableContractId, ZonedDateTime expiresAt, String storageName, HashId value); @Override HashId getUbotStorageValue(HashId executableContractId, String storageName); @Override void getUbotStorages(HashId executableContractId, Map<String, HashId> dest); @Override UbotSessionCompact loadUbotSession(HashId executableContractId); @Override UbotSessionCompact loadUbotSessionByRequestId(HashId requestId); @Override UbotSessionCompact loadUbotSessionById(HashId sessionId); @Override boolean hasUbotSession(HashId executableContractId); @Override void deleteUbotSession(HashId executableContractId); @Override void deleteExpiredUbotSessions(); @Override void deleteExpiredUbotStorages(); @Override void saveUbotTransaction(HashId executableContractId, String transactionName, Binder state); @Override Binder loadUbotTransaction(HashId executableContractId, String transactionName); }
PostgresLedger implements Ledger { @Override public void destroy(StateRecord record) { long recordId = record.getRecordId(); if (recordId == 0) { throw new IllegalStateException("can't destroy record without recordId"); } protect(() -> { inPool(d -> { d.update("DELETE FROM ledger WHERE id = ?", recordId); return null; }); synchronized (cachedRecords) { cachedRecords.remove(record.getId()); } synchronized (cachedRecordsById) { cachedRecordsById.remove(record.getRecordId()); } return null; }); } PostgresLedger(String connectionString, Properties properties); PostgresLedger(String connectionString); final T inPool(DbPool.DbConsumer<T> consumer); @Override StateRecord getRecord(HashId itemId); @Override StateRecord createOutputLockRecord(long creatorRecordId, HashId newItemHashId); @Override StateRecord getLockOwnerOf(StateRecord rc); @Override StateRecord findOrCreate(HashId itemId); @Override Map<HashId,StateRecord> findUnfinished(); @Override Approvable getItem(final StateRecord record); @Override void putItem(StateRecord record, Approvable item, Instant keepTill); @Override byte[] getKeepingItem(HashId itemId); @Override @Deprecated Object getKeepingByOrigin(HashId origin, int limit); @Override Binder getKeepingBy(String field, HashId id, Binder tags, int limit, int offset, String sortBy, String sortOrder); @Override void putKeepingItem(StateRecord record, Approvable item); @Override void close(); @Override long countRecords(); @Override Map<ItemState, Integer> getLedgerSize(ZonedDateTime createdAfter); @Override T transaction(Callable<T> callable); void testClearLedger(); @Override void destroy(StateRecord record); @Override void markTestRecord(HashId hash); @Override boolean isTestnet(HashId itemId); @Override void save(StateRecord stateRecord); @Override void reload(StateRecord stateRecord); void enableCache(boolean enable); Db getDb(); @Override void saveConfig(NodeInfo myInfo, NetConfig netConfig, PrivateKey nodeKey); @Override Object[] loadConfig(); @Override void addNode(NodeInfo nodeInfo); @Override void removeNode(NodeInfo nodeInfo); void cleanup(boolean isPermanetMode); void savePayment(int amount, ZonedDateTime date); Map<Integer,Integer> getPayments(ZonedDateTime fromDate); @Override NImmutableEnvironment getEnvironment(long environmentId); @Override NImmutableEnvironment getEnvironment(HashId contractId); @Override NImmutableEnvironment getEnvironment(NSmartContract smartContract); @Override void updateSubscriptionInStorage(long subscriptionId, ZonedDateTime expiresAt); @Override void updateStorageExpiresAt(long storageId, ZonedDateTime expiresAt); @Override void saveFollowerEnvironment(long environmentId, ZonedDateTime expiresAt, ZonedDateTime mutedAt, double spent, int startedCallbacks); @Override void updateNameRecord(long nameRecordId, ZonedDateTime expiresAt); @Override Set<HashId> saveEnvironment(NImmutableEnvironment environment); @Override Set<HashId> findBadReferencesOf(Set<HashId> ids); @Override long saveSubscriptionInStorage(HashId hashId, boolean subscriptionOnChain, ZonedDateTime expiresAt, long environmentId); @Override void clearExpiredSubscriptions(); @Override void clearExpiredStorages(); @Override void clearExpiredStorageContractBinaries(); @Override void updateEnvironment(long id, String ncontractType, HashId ncontractHashId, byte[] kvStorage, byte[] transactionPack); @Override Set<Long> getSubscriptionEnviromentIds(HashId id); @Override NCallbackService.FollowerCallbackState getFollowerCallbackStateById(HashId id); @Override Collection<CallbackRecord> getFollowerCallbacksToResyncByEnvId(long environmentId); @Override Collection<CallbackRecord> getFollowerCallbacksToResync(); @Override void addFollowerCallback(HashId id, long environmentId, ZonedDateTime expiresAt, ZonedDateTime storedUntil); @Override void updateFollowerCallbackState(HashId id, NCallbackService.FollowerCallbackState state); @Override void removeFollowerCallback(HashId id); @Override byte[] getSmartContractById(HashId smartContractId); @Override byte[] getContractInStorage(HashId contractId); @Override byte[] getContractInStorage(HashId slotId, HashId contractId); @Override List<byte[]> getContractsInStorageByOrigin(HashId slotId, HashId originId); @Override void removeEnvironmentSubscription(long subscriptionId); @Override void removeEnvironmentStorage(long storageId); @Override long removeEnvironment(HashId ncontractHashId); long getEnvironmentId(HashId ncontractHashId); void removeSubscriptionsByEnvId(long environmentId); void removeStorageContractsByEnvId(long environmentId); @Override void removeExpiredStoragesAndSubscriptionsCascade(); @Override void addNameRecord(final NNameRecord nameRecord); @Override long saveContractInStorage(HashId contractId, byte[] binData, ZonedDateTime expiresAt, HashId origin, long environmentId); @Override void removeNameRecord(NNameRecord nameRecord); @Override void addNameRecordEntry(final NNameRecordEntry nameRecordEntryModel); @Override void removeNameRecordEntry(NNameRecordEntry nameRecordEntry); @Override List<String> isAllNameRecordsAvailable(final Collection<String> reducedNames); @Override List<String> isAllOriginsAvailable(final Collection<HashId> origins); @Override List<String> isAllAddressesAvailable(final Collection<String> addresses); void clearExpiredNameRecords(Duration holdDuration); @Override @Deprecated NNameRecord getNameRecord(final String name); @Override Set<NNameRecord> getNameRecords(final String name); @Override List<NNameRecordEntry> getNameEntries(final long environmentId); @Override @Deprecated List<NNameRecordEntry> getNameEntries(final String nameReduced); @Override List<NNameRecord> getNamesByAddress(String address); @Override List<NNameRecord> getNamesByOrigin(byte[] origin); @Override VoteInfo initiateVoting(Contract contract, ZonedDateTime expiresAt, String roleName, Set<HashId> candidates); @Override VoteInfo getVotingInfo(HashId votingItem); @Override void addVotes(long votingId, long candidateId, List<KeyAddress> votes); @Override List<VoteResult> getVotes(HashId itemId, boolean queryAddresses); @Override void closeVote(HashId itemId); @Override void saveUbotSession(UbotSessionCompact sessionCompact); void saveUbotStorages(HashId executableContractId, ZonedDateTime expiresAt, Map<String, HashId> storages); @Override void saveUbotStorageValue(HashId executableContractId, ZonedDateTime expiresAt, String storageName, HashId value); @Override HashId getUbotStorageValue(HashId executableContractId, String storageName); @Override void getUbotStorages(HashId executableContractId, Map<String, HashId> dest); @Override UbotSessionCompact loadUbotSession(HashId executableContractId); @Override UbotSessionCompact loadUbotSessionByRequestId(HashId requestId); @Override UbotSessionCompact loadUbotSessionById(HashId sessionId); @Override boolean hasUbotSession(HashId executableContractId); @Override void deleteUbotSession(HashId executableContractId); @Override void deleteExpiredUbotSessions(); @Override void deleteExpiredUbotStorages(); @Override void saveUbotTransaction(HashId executableContractId, String transactionName, Binder state); @Override Binder loadUbotTransaction(HashId executableContractId, String transactionName); final static String SEARCH_TAGS; }
@Test public void interceptStdout() throws Exception { String result = ConsoleInterceptor.copyOut(() ->{ System.out.print("hello world"); System.out.print('!'); System.out.println(); System.out.println("foobar"); }); assertEquals("hello world!\nfoobar\n", result); result = ConsoleInterceptor.copyOut( () ->{ System.out.print("hello"); System.out.println(" world!"); }); assertEquals("hello world!\n", result); result = ConsoleInterceptor.copyOut( () ->{ System.out.print(58387); System.out.println(" world!"); }); assertEquals("58387 world!\n", result); }
public static String copyOut(Block block) throws Exception { final ByteArrayOutputStream bos = new ByteArrayOutputStream(); final PrintStream printStream = new PrintStream(bos, true); PrintStream oldStream = System.out; PrintStream oldErr = System.err; System.setOut(printStream); System.setErr(printStream); try { block.call(); } finally { System.setOut(oldStream); System.setErr(oldErr); } return bos.toString(); }
ConsoleInterceptor { public static String copyOut(Block block) throws Exception { final ByteArrayOutputStream bos = new ByteArrayOutputStream(); final PrintStream printStream = new PrintStream(bos, true); PrintStream oldStream = System.out; PrintStream oldErr = System.err; System.setOut(printStream); System.setErr(printStream); try { block.call(); } finally { System.setOut(oldStream); System.setErr(oldErr); } return bos.toString(); } }
ConsoleInterceptor { public static String copyOut(Block block) throws Exception { final ByteArrayOutputStream bos = new ByteArrayOutputStream(); final PrintStream printStream = new PrintStream(bos, true); PrintStream oldStream = System.out; PrintStream oldErr = System.err; System.setOut(printStream); System.setErr(printStream); try { block.call(); } finally { System.setOut(oldStream); System.setErr(oldErr); } return bos.toString(); } }
ConsoleInterceptor { public static String copyOut(Block block) throws Exception { final ByteArrayOutputStream bos = new ByteArrayOutputStream(); final PrintStream printStream = new PrintStream(bos, true); PrintStream oldStream = System.out; PrintStream oldErr = System.err; System.setOut(printStream); System.setErr(printStream); try { block.call(); } finally { System.setOut(oldStream); System.setErr(oldErr); } return bos.toString(); } static String copyOut(Block block); }
ConsoleInterceptor { public static String copyOut(Block block) throws Exception { final ByteArrayOutputStream bos = new ByteArrayOutputStream(); final PrintStream printStream = new PrintStream(bos, true); PrintStream oldStream = System.out; PrintStream oldErr = System.err; System.setOut(printStream); System.setErr(printStream); try { block.call(); } finally { System.setOut(oldStream); System.setErr(oldErr); } return bos.toString(); } static String copyOut(Block block); }
@Test public void isFrozen() throws Exception { Binder b = new Binder(); b.put("hello", "world"); Binder x = b.getOrCreateBinder("inner"); x.put("foo", "bar"); assertFalse(b.isFrozen()); assertFalse(b.getBinder("inner").isFrozen()); b.freeze(); assertTrue(b.isFrozen()); assertTrue(b.getBinder("inner").isFrozen()); assertEquals("bar", b.getBinder("inner").get("foo")); Binder e = Binder.EMPTY; assertTrue(e.isFrozen()); x = new Binder(); assertEquals(e, x); assertFalse(b.equals(e)); }
public boolean isFrozen() { return frozen; }
Binder extends HashMap<String, Object> implements Serializable { public boolean isFrozen() { return frozen; } }
Binder extends HashMap<String, Object> implements Serializable { public boolean isFrozen() { return frozen; } Binder(Map copyFrom); Binder(); Binder(Object... keyValuePairs); }
Binder extends HashMap<String, Object> implements Serializable { public boolean isFrozen() { return frozen; } Binder(Map copyFrom); Binder(); Binder(Object... keyValuePairs); static Binder fromKeysValues(Object... args); boolean isFrozen(); Double getDouble(String key); String getStringOrThrow(String key); String getString(String key, String defaultValue); String getString(String key); byte[] getBinary(String key); @NonNull byte[] getBinaryOrThrow(String key); @Deprecated boolean getBoolean(String key); Boolean getBoolean(String key, Boolean defaultValue); Boolean getBooleanOrThrow(String key); @Deprecated Binder of(String key); static Binder of(String key, Object value, Object... keysValues); Binder getOrCreateBinder(String key); Binder getBinder(String key); Binder getBinderOrThrow(String key); Binder getBinder(String key, Binder defaultValue); @Deprecated int getInt(String key); int getIntOrThrow(String key); @Deprecated long getLong(String key); long getLong(String key, long defaultValue); Integer getInt(String key, Integer defaultValue); ArrayList<?> getArray(String key); ArrayList<Binder> getBinders(String key); T set(String key, T object); Binder unmodifiableCopy(); void freeze(); static Binder from(Object x); static T convertAllMapsToBinders(Object object); static Binder of(Object x); Binder putAll(String key, Object value, Object... keyValuePairs); ZonedDateTime getZonedDateTime(String key, ZonedDateTime defaultValue); ZonedDateTime getZonedDateTimeOrThrow(String key); long getLongOrThrow(String key); Bytes getBytesOrThrow(String key); T getOrThrow(String key); List<T> getOrCreateList(String key); List<T> getList(String key, List<T> defaultValue); List getListOrThrow(String key); int addToInt(String name, int delta); Binder getBinderOrThrow(String... path); String getStringOrThrow(String... path); T getOrThrow(String... path); T getOrNull(String... path); }
Binder extends HashMap<String, Object> implements Serializable { public boolean isFrozen() { return frozen; } Binder(Map copyFrom); Binder(); Binder(Object... keyValuePairs); static Binder fromKeysValues(Object... args); boolean isFrozen(); Double getDouble(String key); String getStringOrThrow(String key); String getString(String key, String defaultValue); String getString(String key); byte[] getBinary(String key); @NonNull byte[] getBinaryOrThrow(String key); @Deprecated boolean getBoolean(String key); Boolean getBoolean(String key, Boolean defaultValue); Boolean getBooleanOrThrow(String key); @Deprecated Binder of(String key); static Binder of(String key, Object value, Object... keysValues); Binder getOrCreateBinder(String key); Binder getBinder(String key); Binder getBinderOrThrow(String key); Binder getBinder(String key, Binder defaultValue); @Deprecated int getInt(String key); int getIntOrThrow(String key); @Deprecated long getLong(String key); long getLong(String key, long defaultValue); Integer getInt(String key, Integer defaultValue); ArrayList<?> getArray(String key); ArrayList<Binder> getBinders(String key); T set(String key, T object); Binder unmodifiableCopy(); void freeze(); static Binder from(Object x); static T convertAllMapsToBinders(Object object); static Binder of(Object x); Binder putAll(String key, Object value, Object... keyValuePairs); ZonedDateTime getZonedDateTime(String key, ZonedDateTime defaultValue); ZonedDateTime getZonedDateTimeOrThrow(String key); long getLongOrThrow(String key); Bytes getBytesOrThrow(String key); T getOrThrow(String key); List<T> getOrCreateList(String key); List<T> getList(String key, List<T> defaultValue); List getListOrThrow(String key); int addToInt(String name, int delta); Binder getBinderOrThrow(String... path); String getStringOrThrow(String... path); T getOrThrow(String... path); T getOrNull(String... path); static final Binder EMPTY; }
@Test public void getInt() throws Exception { Binder b = Binder.fromKeysValues( "i1", 100, "i2", "101", "l1", "1505774997427", "l2", 1505774997427L ); assertEquals(100, (int) b.getInt("i1",222)); assertEquals(101, (int) b.getInt("i2",222)); assertEquals(100, b.getIntOrThrow("i1")); assertEquals(101, b.getIntOrThrow("i2")); assertEquals(1505774997427L, b.getLongOrThrow("l1")); assertEquals(1505774997427L, b.getLongOrThrow("l2")); }
@Deprecated public int getInt(String key) { return getIntOrThrow(key); }
Binder extends HashMap<String, Object> implements Serializable { @Deprecated public int getInt(String key) { return getIntOrThrow(key); } }
Binder extends HashMap<String, Object> implements Serializable { @Deprecated public int getInt(String key) { return getIntOrThrow(key); } Binder(Map copyFrom); Binder(); Binder(Object... keyValuePairs); }
Binder extends HashMap<String, Object> implements Serializable { @Deprecated public int getInt(String key) { return getIntOrThrow(key); } Binder(Map copyFrom); Binder(); Binder(Object... keyValuePairs); static Binder fromKeysValues(Object... args); boolean isFrozen(); Double getDouble(String key); String getStringOrThrow(String key); String getString(String key, String defaultValue); String getString(String key); byte[] getBinary(String key); @NonNull byte[] getBinaryOrThrow(String key); @Deprecated boolean getBoolean(String key); Boolean getBoolean(String key, Boolean defaultValue); Boolean getBooleanOrThrow(String key); @Deprecated Binder of(String key); static Binder of(String key, Object value, Object... keysValues); Binder getOrCreateBinder(String key); Binder getBinder(String key); Binder getBinderOrThrow(String key); Binder getBinder(String key, Binder defaultValue); @Deprecated int getInt(String key); int getIntOrThrow(String key); @Deprecated long getLong(String key); long getLong(String key, long defaultValue); Integer getInt(String key, Integer defaultValue); ArrayList<?> getArray(String key); ArrayList<Binder> getBinders(String key); T set(String key, T object); Binder unmodifiableCopy(); void freeze(); static Binder from(Object x); static T convertAllMapsToBinders(Object object); static Binder of(Object x); Binder putAll(String key, Object value, Object... keyValuePairs); ZonedDateTime getZonedDateTime(String key, ZonedDateTime defaultValue); ZonedDateTime getZonedDateTimeOrThrow(String key); long getLongOrThrow(String key); Bytes getBytesOrThrow(String key); T getOrThrow(String key); List<T> getOrCreateList(String key); List<T> getList(String key, List<T> defaultValue); List getListOrThrow(String key); int addToInt(String name, int delta); Binder getBinderOrThrow(String... path); String getStringOrThrow(String... path); T getOrThrow(String... path); T getOrNull(String... path); }
Binder extends HashMap<String, Object> implements Serializable { @Deprecated public int getInt(String key) { return getIntOrThrow(key); } Binder(Map copyFrom); Binder(); Binder(Object... keyValuePairs); static Binder fromKeysValues(Object... args); boolean isFrozen(); Double getDouble(String key); String getStringOrThrow(String key); String getString(String key, String defaultValue); String getString(String key); byte[] getBinary(String key); @NonNull byte[] getBinaryOrThrow(String key); @Deprecated boolean getBoolean(String key); Boolean getBoolean(String key, Boolean defaultValue); Boolean getBooleanOrThrow(String key); @Deprecated Binder of(String key); static Binder of(String key, Object value, Object... keysValues); Binder getOrCreateBinder(String key); Binder getBinder(String key); Binder getBinderOrThrow(String key); Binder getBinder(String key, Binder defaultValue); @Deprecated int getInt(String key); int getIntOrThrow(String key); @Deprecated long getLong(String key); long getLong(String key, long defaultValue); Integer getInt(String key, Integer defaultValue); ArrayList<?> getArray(String key); ArrayList<Binder> getBinders(String key); T set(String key, T object); Binder unmodifiableCopy(); void freeze(); static Binder from(Object x); static T convertAllMapsToBinders(Object object); static Binder of(Object x); Binder putAll(String key, Object value, Object... keyValuePairs); ZonedDateTime getZonedDateTime(String key, ZonedDateTime defaultValue); ZonedDateTime getZonedDateTimeOrThrow(String key); long getLongOrThrow(String key); Bytes getBytesOrThrow(String key); T getOrThrow(String key); List<T> getOrCreateList(String key); List<T> getList(String key, List<T> defaultValue); List getListOrThrow(String key); int addToInt(String name, int delta); Binder getBinderOrThrow(String... path); String getStringOrThrow(String... path); T getOrThrow(String... path); T getOrNull(String... path); static final Binder EMPTY; }
@Test public void fingerprint() throws Exception { PrivateKey k = TestKeys.privateKey(0); byte[] f1 = k.getPublicKey().fingerprint(); assertEquals(33, f1.length); byte[] f2 = k.fingerprint(); assertArrayEquals(f1, f2); assertEquals(AbstractKey.FINGERPRINT_SHA256, f1[0]); }
public byte[] fingerprint() { throw new RuntimeException("this key does not support fingerprints"); }
AbstractKey implements Bindable, KeyMatcher { public byte[] fingerprint() { throw new RuntimeException("this key does not support fingerprints"); } }
AbstractKey implements Bindable, KeyMatcher { public byte[] fingerprint() { throw new RuntimeException("this key does not support fingerprints"); } }
AbstractKey implements Bindable, KeyMatcher { public byte[] fingerprint() { throw new RuntimeException("this key does not support fingerprints"); } byte[] encrypt(byte[] plain); byte[] decrypt(byte[] plain); byte[] sign(InputStream input, HashType hashType); byte[] sign(byte[] input, HashType hashType); boolean verify(InputStream input, byte[] signature, HashType hashType); boolean verify(byte[] input, byte[] signature, HashType hashType); boolean verify(String input, byte[] signature, HashType hashType); KeyInfo info(); byte[] packedInfo(); byte[] pack(); String packToBase64String(); void unpack(byte[] bytes); boolean canSign(); boolean isPublic(); boolean isPrivate(); AbstractKey getPublicKey(); @Override final Binder toBinder(); @Override final T updateFrom(Binder source); static AbstractKey fromBinder(Binder binder); boolean matchType(AbstractKey other); boolean matchTag(AbstractKey other); void setTag(String tag); void setTag(byte[] tag); @Override String toString(); Capsule.KeySource asKeySource(); byte[] fingerprint(); Digest updateDigestWithKeyComponents(Digest digest); byte[] createAnonymousId(); boolean matchAnonymousId(@NonNull byte[] packedId); KeyAddress address(boolean useSha3_384, int keyMark); final KeyAddress getShortAddress(); final KeyAddress getLongAddress(); @Override boolean isMatchingKey(AbstractKey key); @Override final boolean isMatchingKeyAddress(KeyAddress other); }
AbstractKey implements Bindable, KeyMatcher { public byte[] fingerprint() { throw new RuntimeException("this key does not support fingerprints"); } byte[] encrypt(byte[] plain); byte[] decrypt(byte[] plain); byte[] sign(InputStream input, HashType hashType); byte[] sign(byte[] input, HashType hashType); boolean verify(InputStream input, byte[] signature, HashType hashType); boolean verify(byte[] input, byte[] signature, HashType hashType); boolean verify(String input, byte[] signature, HashType hashType); KeyInfo info(); byte[] packedInfo(); byte[] pack(); String packToBase64String(); void unpack(byte[] bytes); boolean canSign(); boolean isPublic(); boolean isPrivate(); AbstractKey getPublicKey(); @Override final Binder toBinder(); @Override final T updateFrom(Binder source); static AbstractKey fromBinder(Binder binder); boolean matchType(AbstractKey other); boolean matchTag(AbstractKey other); void setTag(String tag); void setTag(byte[] tag); @Override String toString(); Capsule.KeySource asKeySource(); byte[] fingerprint(); Digest updateDigestWithKeyComponents(Digest digest); byte[] createAnonymousId(); boolean matchAnonymousId(@NonNull byte[] packedId); KeyAddress address(boolean useSha3_384, int keyMark); final KeyAddress getShortAddress(); final KeyAddress getLongAddress(); @Override boolean isMatchingKey(AbstractKey key); @Override final boolean isMatchingKeyAddress(KeyAddress other); static final int FINGERPRINT_SHA256; static final int FINGERPRINT_SHA384; static final int TYPE_PRIVATE; static final int TYPE_PUBLIC; static final int TYPE_PRIVATE_PASSWORD; static final int TYPE_PRIVATE_PASSWORD_V2; }
@Test public void average() throws Exception { Average a = new Average(); for( int i=0; i<5; i++) a.update(i); for( int i=4; i>=0; i--) a.update(i); assertTrue(a.toString().startsWith("2.0±1.414213562373095")); assertEquals(1.490711985, a.correctedStdev(), 0.00001); }
public double average() { if (n < 1) throw new IllegalStateException("too few samples"); return sum / n; }
Average { public double average() { if (n < 1) throw new IllegalStateException("too few samples"); return sum / n; } }
Average { public double average() { if (n < 1) throw new IllegalStateException("too few samples"); return sum / n; } }
Average { public double average() { if (n < 1) throw new IllegalStateException("too few samples"); return sum / n; } synchronized long update(double value); double average(); double stdev2(); double stdev(); long length(); double correctedStdev(); @Override String toString(); double variation(); }
Average { public double average() { if (n < 1) throw new IllegalStateException("too few samples"); return sum / n; } synchronized long update(double value); double average(); double stdev2(); double stdev(); long length(); double correctedStdev(); @Override String toString(); double variation(); }
@Test public void testRestart() throws Exception { executorService.submit(() -> System.out.println("warm up executor")); Thread.sleep(1000); List<Integer> periods = Arrays.asList(0,100,100,100,200,400,800,1600,3200,6000); time = System.nanoTime(); AtomicInteger iTick = new AtomicInteger(0); AtomicInteger errorsCount = new AtomicInteger(0); RunnableWithDynamicPeriod r = new RunnableWithDynamicPeriod(() -> { long t1 = System.nanoTime(); long dt = (t1 - time) / 1000000; time = t1; long dt0 = periods.get(Math.min(iTick.get(), periods.size()-1)); System.out.println("tick "+iTick.get()+": " + dt + "ms, must be " + dt0 + "ms"); if (!(Math.abs(dt0 - dt) < 5+dt0/10)) errorsCount.incrementAndGet(); iTick.incrementAndGet(); }, periods, executorService); r.run(); Thread.sleep(8500); r.restart(); iTick.set(0); time = System.nanoTime(); Thread.sleep(10000); System.out.println("executorService.size: " + executorService.getQueue().size()); Assert.assertEquals(1, executorService.getQueue().size()); r.cancel(true); while (executorService.getQueue().size() > 0) { Thread.sleep(1000); System.out.println("executorService.size: " + executorService.getQueue().size()); } Assert.assertEquals(0, executorService.getQueue().size()); Assert.assertEquals(0, errorsCount.get()); }
public void restart() { waitsCount = 0; if (future != null) future.cancel(true); run(); }
RunnableWithDynamicPeriod implements Runnable { public void restart() { waitsCount = 0; if (future != null) future.cancel(true); run(); } }
RunnableWithDynamicPeriod implements Runnable { public void restart() { waitsCount = 0; if (future != null) future.cancel(true); run(); } RunnableWithDynamicPeriod(Runnable lambda, List<Integer> periods, ScheduledExecutorService es); }
RunnableWithDynamicPeriod implements Runnable { public void restart() { waitsCount = 0; if (future != null) future.cancel(true); run(); } RunnableWithDynamicPeriod(Runnable lambda, List<Integer> periods, ScheduledExecutorService es); @Override void run(); void cancel(boolean b); void restart(); }
RunnableWithDynamicPeriod implements Runnable { public void restart() { waitsCount = 0; if (future != null) future.cancel(true); run(); } RunnableWithDynamicPeriod(Runnable lambda, List<Integer> periods, ScheduledExecutorService es); @Override void run(); void cancel(boolean b); void restart(); }
@Test public void testCancel() throws Exception { executorService.submit(() -> System.out.println("warm up executor")); Thread.sleep(1000); List<Integer> periods = Arrays.asList(100,100,100,200); time = System.nanoTime(); AtomicInteger iTick = new AtomicInteger(0); AtomicInteger errorsCount = new AtomicInteger(0); RunnableWithDynamicPeriod r = new RunnableWithDynamicPeriod(() -> { long t1 = System.nanoTime(); long dt = (t1 - time) / 1000000; time = t1; long dt0 = periods.get(Math.min(iTick.get(), periods.size()-1)); System.out.println("tick: " + dt + "ms, must be " + dt0 + "ms"); if (!(Math.abs(dt0 - dt) < dt0/10)) errorsCount.incrementAndGet(); iTick.incrementAndGet(); }, periods, executorService); r.run(); System.out.println("wait for ticks"); Thread.sleep(2000); AtomicInteger ticksCount = new AtomicInteger(iTick.get()); System.out.println("now cancel"); r.cancel(true); Thread.sleep(2000); Assert.assertEquals(ticksCount.get(), iTick.get()); }
public void cancel(boolean b) { synchronized (cancelled) { cancelled.set(true); } }
RunnableWithDynamicPeriod implements Runnable { public void cancel(boolean b) { synchronized (cancelled) { cancelled.set(true); } } }
RunnableWithDynamicPeriod implements Runnable { public void cancel(boolean b) { synchronized (cancelled) { cancelled.set(true); } } RunnableWithDynamicPeriod(Runnable lambda, List<Integer> periods, ScheduledExecutorService es); }
RunnableWithDynamicPeriod implements Runnable { public void cancel(boolean b) { synchronized (cancelled) { cancelled.set(true); } } RunnableWithDynamicPeriod(Runnable lambda, List<Integer> periods, ScheduledExecutorService es); @Override void run(); void cancel(boolean b); void restart(); }
RunnableWithDynamicPeriod implements Runnable { public void cancel(boolean b) { synchronized (cancelled) { cancelled.set(true); } } RunnableWithDynamicPeriod(Runnable lambda, List<Integer> periods, ScheduledExecutorService es); @Override void run(); void cancel(boolean b); void restart(); }
@Test public void slice() throws Exception { BufferedLogger log = new BufferedLogger(100); for (int i = 0; i < 10; i++) { log.log("line " + i); } log.flush(); List<BufferedLogger.Entry> all = log.getCopy(); List<BufferedLogger.Entry> entries = log.slice(all.get(5).id, 3); String result = str(entries); assertEquals("line 6,line 7,line 8", result); result = str(log.slice(all.get(5).id, -3)); assertEquals("line 2,line 3,line 4", result); result = str(log.slice(all.get(2).id, -3)); assertEquals("line 0,line 1", result); result = str(log.slice(all.get(8).id, +3)); assertEquals("line 9", result); result = str(log.slice(all.get(0).id, 20)); assertEquals("line 1,line 2,line 3,line 4,line 5,line 6,line 7,line 8,line 9", result); result = str(log.slice(all.get(9).id, -20)); assertEquals("line 0,line 1,line 2,line 3,line 4,line 5,line 6,line 7,line 8", result); result = str(log.slice(all.get(0).id-1, 20)); assertEquals("line 0,line 1,line 2,line 3,line 4,line 5,line 6,line 7,line 8,line 9", result); }
public List<Entry> slice(long id, int maxEntries) { List<Entry> copy = getCopy(); Entry start = new Entry(id); int fromIndex = Collections.binarySearch(copy, start); if (maxEntries > 0) fromIndex++; if (fromIndex < 0) fromIndex = 0; int toIndex = fromIndex + maxEntries; if (toIndex < fromIndex) { int t = fromIndex; fromIndex = toIndex; toIndex = t; } int length = copy.size(); if (fromIndex < 0) fromIndex = 0; if (toIndex >= length) toIndex = length; if (fromIndex >= length || toIndex < 1 || fromIndex == toIndex) return Collections.emptyList(); return copy.subList(fromIndex, toIndex); }
BufferedLogger implements AutoCloseable { public List<Entry> slice(long id, int maxEntries) { List<Entry> copy = getCopy(); Entry start = new Entry(id); int fromIndex = Collections.binarySearch(copy, start); if (maxEntries > 0) fromIndex++; if (fromIndex < 0) fromIndex = 0; int toIndex = fromIndex + maxEntries; if (toIndex < fromIndex) { int t = fromIndex; fromIndex = toIndex; toIndex = t; } int length = copy.size(); if (fromIndex < 0) fromIndex = 0; if (toIndex >= length) toIndex = length; if (fromIndex >= length || toIndex < 1 || fromIndex == toIndex) return Collections.emptyList(); return copy.subList(fromIndex, toIndex); } }
BufferedLogger implements AutoCloseable { public List<Entry> slice(long id, int maxEntries) { List<Entry> copy = getCopy(); Entry start = new Entry(id); int fromIndex = Collections.binarySearch(copy, start); if (maxEntries > 0) fromIndex++; if (fromIndex < 0) fromIndex = 0; int toIndex = fromIndex + maxEntries; if (toIndex < fromIndex) { int t = fromIndex; fromIndex = toIndex; toIndex = t; } int length = copy.size(); if (fromIndex < 0) fromIndex = 0; if (toIndex >= length) toIndex = length; if (fromIndex >= length || toIndex < 1 || fromIndex == toIndex) return Collections.emptyList(); return copy.subList(fromIndex, toIndex); } BufferedLogger(int maxEntries); }
BufferedLogger implements AutoCloseable { public List<Entry> slice(long id, int maxEntries) { List<Entry> copy = getCopy(); Entry start = new Entry(id); int fromIndex = Collections.binarySearch(copy, start); if (maxEntries > 0) fromIndex++; if (fromIndex < 0) fromIndex = 0; int toIndex = fromIndex + maxEntries; if (toIndex < fromIndex) { int t = fromIndex; fromIndex = toIndex; toIndex = t; } int length = copy.size(); if (fromIndex < 0) fromIndex = 0; if (toIndex >= length) toIndex = length; if (fromIndex >= length || toIndex < 1 || fromIndex == toIndex) return Collections.emptyList(); return copy.subList(fromIndex, toIndex); } BufferedLogger(int maxEntries); void e(String s); void flush(); boolean flush(long millis); PrintStream printTo(PrintStream ps, boolean printTimestamp); @NonNull Entry log(String message); @NonNull Entry d(String message); @NonNull List<Entry> getLast(int maxEntries); List<Entry> slice(long id, int maxEntries); void clear(); List<Entry> getCopy(); void interceptStdOut(); @Override void close(); void stopInterceptingStdOut(); }
BufferedLogger implements AutoCloseable { public List<Entry> slice(long id, int maxEntries) { List<Entry> copy = getCopy(); Entry start = new Entry(id); int fromIndex = Collections.binarySearch(copy, start); if (maxEntries > 0) fromIndex++; if (fromIndex < 0) fromIndex = 0; int toIndex = fromIndex + maxEntries; if (toIndex < fromIndex) { int t = fromIndex; fromIndex = toIndex; toIndex = t; } int length = copy.size(); if (fromIndex < 0) fromIndex = 0; if (toIndex >= length) toIndex = length; if (fromIndex >= length || toIndex < 1 || fromIndex == toIndex) return Collections.emptyList(); return copy.subList(fromIndex, toIndex); } BufferedLogger(int maxEntries); void e(String s); void flush(); boolean flush(long millis); PrintStream printTo(PrintStream ps, boolean printTimestamp); @NonNull Entry log(String message); @NonNull Entry d(String message); @NonNull List<Entry> getLast(int maxEntries); List<Entry> slice(long id, int maxEntries); void clear(); List<Entry> getCopy(); void interceptStdOut(); @Override void close(); void stopInterceptingStdOut(); }
@Test public void log() throws Exception { BufferedLogger log = new BufferedLogger(3); for (int i = 0; i < 10; i++) { log.log("line " + i); } log.flush(); assertEquals("line 7,line 8,line 9", str(log.getCopy())); }
public @NonNull Entry log(String message) { Entry entry = new Entry(message); queue.add(entry); return entry; }
BufferedLogger implements AutoCloseable { public @NonNull Entry log(String message) { Entry entry = new Entry(message); queue.add(entry); return entry; } }
BufferedLogger implements AutoCloseable { public @NonNull Entry log(String message) { Entry entry = new Entry(message); queue.add(entry); return entry; } BufferedLogger(int maxEntries); }
BufferedLogger implements AutoCloseable { public @NonNull Entry log(String message) { Entry entry = new Entry(message); queue.add(entry); return entry; } BufferedLogger(int maxEntries); void e(String s); void flush(); boolean flush(long millis); PrintStream printTo(PrintStream ps, boolean printTimestamp); @NonNull Entry log(String message); @NonNull Entry d(String message); @NonNull List<Entry> getLast(int maxEntries); List<Entry> slice(long id, int maxEntries); void clear(); List<Entry> getCopy(); void interceptStdOut(); @Override void close(); void stopInterceptingStdOut(); }
BufferedLogger implements AutoCloseable { public @NonNull Entry log(String message) { Entry entry = new Entry(message); queue.add(entry); return entry; } BufferedLogger(int maxEntries); void e(String s); void flush(); boolean flush(long millis); PrintStream printTo(PrintStream ps, boolean printTimestamp); @NonNull Entry log(String message); @NonNull Entry d(String message); @NonNull List<Entry> getLast(int maxEntries); List<Entry> slice(long id, int maxEntries); void clear(); List<Entry> getCopy(); void interceptStdOut(); @Override void close(); void stopInterceptingStdOut(); }
@Test public void snakeToCamelCase() throws Exception { assertEquals("HelloWorld!", Do.snakeToCamelCase("hello_wORld_!")); assertEquals("Hello", Do.snakeToCamelCase("hello_")); assertEquals("Hello", Do.snakeToCamelCase("hello")); assertEquals("Hello", Do.snakeToCamelCase("_hello")); }
public static String snakeToCamelCase(String snakeString) { StringBuilder b = new StringBuilder(); for(String s: snakeString.split("_") ) { if(s.length() > 0 ) { b.append(Character.toUpperCase(s.charAt(0))); b.append(s.substring(1, s.length()).toLowerCase()); } } return b.toString(); }
Do { public static String snakeToCamelCase(String snakeString) { StringBuilder b = new StringBuilder(); for(String s: snakeString.split("_") ) { if(s.length() > 0 ) { b.append(Character.toUpperCase(s.charAt(0))); b.append(s.substring(1, s.length()).toLowerCase()); } } return b.toString(); } }
Do { public static String snakeToCamelCase(String snakeString) { StringBuilder b = new StringBuilder(); for(String s: snakeString.split("_") ) { if(s.length() > 0 ) { b.append(Character.toUpperCase(s.charAt(0))); b.append(s.substring(1, s.length()).toLowerCase()); } } return b.toString(); } }
Do { public static String snakeToCamelCase(String snakeString) { StringBuilder b = new StringBuilder(); for(String s: snakeString.split("_") ) { if(s.length() > 0 ) { b.append(Character.toUpperCase(s.charAt(0))); b.append(s.substring(1, s.length()).toLowerCase()); } } return b.toString(); } static byte[] read(String fileName); static byte[] read(InputStream inputStream); static String readToString(InputStream inputStream); static A checkSame(A oldValue, B newValue, Runnable onChanged); static T sample(Collection source); static SecureRandom getRng(); static int randomInt(int max); static byte[] randomBytes(int length); static byte[] randomNegativeBytes(int length); static int randomIntInRange(int inclusiveMinimum, int inclusiveMaximum); static byte[] read(File f); static void waitFor(Supplier<Boolean> function); static void delay(long millis, Action action); static void later(Action action); static HashMap<String, Object> map(Object... args); static Collection<T> collection(Object x); static ArrayList<T> list(U x); static ArrayList<T> listOf(U... objects); static boolean deepEqualityTest(Object a, Object b); static byte[] decodeBase64(String base64); static DeferredResult inParallel(final Task task); static DeferredResult inParallel(final TaskWithoutResult task); static String bytesToHex(byte[] bytes); static String snakeToCamelCase(String snakeString); }
Do { public static String snakeToCamelCase(String snakeString) { StringBuilder b = new StringBuilder(); for(String s: snakeString.split("_") ) { if(s.length() > 0 ) { b.append(Character.toUpperCase(s.charAt(0))); b.append(s.substring(1, s.length()).toLowerCase()); } } return b.toString(); } static byte[] read(String fileName); static byte[] read(InputStream inputStream); static String readToString(InputStream inputStream); static A checkSame(A oldValue, B newValue, Runnable onChanged); static T sample(Collection source); static SecureRandom getRng(); static int randomInt(int max); static byte[] randomBytes(int length); static byte[] randomNegativeBytes(int length); static int randomIntInRange(int inclusiveMinimum, int inclusiveMaximum); static byte[] read(File f); static void waitFor(Supplier<Boolean> function); static void delay(long millis, Action action); static void later(Action action); static HashMap<String, Object> map(Object... args); static Collection<T> collection(Object x); static ArrayList<T> list(U x); static ArrayList<T> listOf(U... objects); static boolean deepEqualityTest(Object a, Object b); static byte[] decodeBase64(String base64); static DeferredResult inParallel(final Task task); static DeferredResult inParallel(final TaskWithoutResult task); static String bytesToHex(byte[] bytes); static String snakeToCamelCase(String snakeString); }
@Test public void sample() throws Exception { HashSet<String> x = new HashSet<>(Do.listOf("aa", "bb", "cc", "cd")); HashSet<String> y = new HashSet<>(); ArrayList<String> z = new ArrayList<>(Do.listOf("aa", "bb", "cc", "cd")); HashSet<String> t = new HashSet<>(); int repetitions = 10000; for (int i = 0; i < repetitions; i++) { y.add(Do.sample(x)); t.add(Do.sample(z)); } assertEquals(y,x); }
public static <T> T sample(Collection source) { int size = source.size(); if (size <= 0) return null; int i = Do.randomInt(size); if (source instanceof List && source instanceof RandomAccess) return (T) ((List) source).get(i); else return (T) source.toArray()[i]; }
Do { public static <T> T sample(Collection source) { int size = source.size(); if (size <= 0) return null; int i = Do.randomInt(size); if (source instanceof List && source instanceof RandomAccess) return (T) ((List) source).get(i); else return (T) source.toArray()[i]; } }
Do { public static <T> T sample(Collection source) { int size = source.size(); if (size <= 0) return null; int i = Do.randomInt(size); if (source instanceof List && source instanceof RandomAccess) return (T) ((List) source).get(i); else return (T) source.toArray()[i]; } }
Do { public static <T> T sample(Collection source) { int size = source.size(); if (size <= 0) return null; int i = Do.randomInt(size); if (source instanceof List && source instanceof RandomAccess) return (T) ((List) source).get(i); else return (T) source.toArray()[i]; } static byte[] read(String fileName); static byte[] read(InputStream inputStream); static String readToString(InputStream inputStream); static A checkSame(A oldValue, B newValue, Runnable onChanged); static T sample(Collection source); static SecureRandom getRng(); static int randomInt(int max); static byte[] randomBytes(int length); static byte[] randomNegativeBytes(int length); static int randomIntInRange(int inclusiveMinimum, int inclusiveMaximum); static byte[] read(File f); static void waitFor(Supplier<Boolean> function); static void delay(long millis, Action action); static void later(Action action); static HashMap<String, Object> map(Object... args); static Collection<T> collection(Object x); static ArrayList<T> list(U x); static ArrayList<T> listOf(U... objects); static boolean deepEqualityTest(Object a, Object b); static byte[] decodeBase64(String base64); static DeferredResult inParallel(final Task task); static DeferredResult inParallel(final TaskWithoutResult task); static String bytesToHex(byte[] bytes); static String snakeToCamelCase(String snakeString); }
Do { public static <T> T sample(Collection source) { int size = source.size(); if (size <= 0) return null; int i = Do.randomInt(size); if (source instanceof List && source instanceof RandomAccess) return (T) ((List) source).get(i); else return (T) source.toArray()[i]; } static byte[] read(String fileName); static byte[] read(InputStream inputStream); static String readToString(InputStream inputStream); static A checkSame(A oldValue, B newValue, Runnable onChanged); static T sample(Collection source); static SecureRandom getRng(); static int randomInt(int max); static byte[] randomBytes(int length); static byte[] randomNegativeBytes(int length); static int randomIntInRange(int inclusiveMinimum, int inclusiveMaximum); static byte[] read(File f); static void waitFor(Supplier<Boolean> function); static void delay(long millis, Action action); static void later(Action action); static HashMap<String, Object> map(Object... args); static Collection<T> collection(Object x); static ArrayList<T> list(U x); static ArrayList<T> listOf(U... objects); static boolean deepEqualityTest(Object a, Object b); static byte[] decodeBase64(String base64); static DeferredResult inParallel(final Task task); static DeferredResult inParallel(final TaskWithoutResult task); static String bytesToHex(byte[] bytes); static String snakeToCamelCase(String snakeString); }
@Test public void randomInt() throws Exception { double sum = 0; int repetitions = 20000; int min = 10000, max = -1000; for(int i=0; i < repetitions; i++ ) { int x = Do.randomInt(100); sum += x; if( x < min ) min = x; if( x > max ) max = x; } sum /= repetitions; assertThat( sum, is(closeTo(50, 0.9))); assertThat(min, is(lessThan(20))); assertThat(max, is(greaterThan(80))); }
public static int randomInt(int max) { return getRng().nextInt(max); }
Do { public static int randomInt(int max) { return getRng().nextInt(max); } }
Do { public static int randomInt(int max) { return getRng().nextInt(max); } }
Do { public static int randomInt(int max) { return getRng().nextInt(max); } static byte[] read(String fileName); static byte[] read(InputStream inputStream); static String readToString(InputStream inputStream); static A checkSame(A oldValue, B newValue, Runnable onChanged); static T sample(Collection source); static SecureRandom getRng(); static int randomInt(int max); static byte[] randomBytes(int length); static byte[] randomNegativeBytes(int length); static int randomIntInRange(int inclusiveMinimum, int inclusiveMaximum); static byte[] read(File f); static void waitFor(Supplier<Boolean> function); static void delay(long millis, Action action); static void later(Action action); static HashMap<String, Object> map(Object... args); static Collection<T> collection(Object x); static ArrayList<T> list(U x); static ArrayList<T> listOf(U... objects); static boolean deepEqualityTest(Object a, Object b); static byte[] decodeBase64(String base64); static DeferredResult inParallel(final Task task); static DeferredResult inParallel(final TaskWithoutResult task); static String bytesToHex(byte[] bytes); static String snakeToCamelCase(String snakeString); }
Do { public static int randomInt(int max) { return getRng().nextInt(max); } static byte[] read(String fileName); static byte[] read(InputStream inputStream); static String readToString(InputStream inputStream); static A checkSame(A oldValue, B newValue, Runnable onChanged); static T sample(Collection source); static SecureRandom getRng(); static int randomInt(int max); static byte[] randomBytes(int length); static byte[] randomNegativeBytes(int length); static int randomIntInRange(int inclusiveMinimum, int inclusiveMaximum); static byte[] read(File f); static void waitFor(Supplier<Boolean> function); static void delay(long millis, Action action); static void later(Action action); static HashMap<String, Object> map(Object... args); static Collection<T> collection(Object x); static ArrayList<T> list(U x); static ArrayList<T> listOf(U... objects); static boolean deepEqualityTest(Object a, Object b); static byte[] decodeBase64(String base64); static DeferredResult inParallel(final Task task); static DeferredResult inParallel(final TaskWithoutResult task); static String bytesToHex(byte[] bytes); static String snakeToCamelCase(String snakeString); }
@Test public void success() throws Exception { DeferredResult dr = new DeferredResult(); dr.success( (text-> assertEquals("hello", text))); dr.sendSuccess("hello"); }
public DeferredResult success(Handler handler) { synchronized (successHandlers) { successHandlers.add(handler); } if (done && success) invokeSuccess(); return this; }
DeferredResult { public DeferredResult success(Handler handler) { synchronized (successHandlers) { successHandlers.add(handler); } if (done && success) invokeSuccess(); return this; } }
DeferredResult { public DeferredResult success(Handler handler) { synchronized (successHandlers) { successHandlers.add(handler); } if (done && success) invokeSuccess(); return this; } }
DeferredResult { public DeferredResult success(Handler handler) { synchronized (successHandlers) { successHandlers.add(handler); } if (done && success) invokeSuccess(); return this; } DeferredResult success(Handler handler); DeferredResult failure(Handler handler); DeferredResult done(Handler handler); void sendSuccess(Object data); void sendFailure(Object data); boolean isDone(); @SuppressWarnings("unchecked") T getResult(); T waitSuccess(); T await(); T await(long millis); final DeferredResult join(); boolean isSuccess(); final boolean join(long millis); }
DeferredResult { public DeferredResult success(Handler handler) { synchronized (successHandlers) { successHandlers.add(handler); } if (done && success) invokeSuccess(); return this; } DeferredResult success(Handler handler); DeferredResult failure(Handler handler); DeferredResult done(Handler handler); void sendSuccess(Object data); void sendFailure(Object data); boolean isDone(); @SuppressWarnings("unchecked") T getResult(); T waitSuccess(); T await(); T await(long millis); final DeferredResult join(); boolean isSuccess(); final boolean join(long millis); }
@Test public void fire() throws Exception { for(int n=0; n<500; n++) { AsyncEvent<Integer> event = new AsyncEvent<>(); int values[] = new int[] { 0, 0}; CountDownLatch latch = new CountDownLatch(2); event.addConsumer(i -> { values[0] = i; latch.countDown(); }); event.addConsumer(i -> { values[1] = i; latch.countDown(); }); event.fire(11); int res = event.waitFired(); assertEquals(11, res); latch.await(); assertEquals(11, values[0]); assertEquals(11, values[1]); } }
public void fire(T result) { synchronized (mutex) { this.result = result; fired = true; for (Consumer<T> consumer : consumers) pool.execute(() -> consumer.accept(result)); consumers.clear(); mutex.notifyAll(); } }
AsyncEvent { public void fire(T result) { synchronized (mutex) { this.result = result; fired = true; for (Consumer<T> consumer : consumers) pool.execute(() -> consumer.accept(result)); consumers.clear(); mutex.notifyAll(); } } }
AsyncEvent { public void fire(T result) { synchronized (mutex) { this.result = result; fired = true; for (Consumer<T> consumer : consumers) pool.execute(() -> consumer.accept(result)); consumers.clear(); mutex.notifyAll(); } } }
AsyncEvent { public void fire(T result) { synchronized (mutex) { this.result = result; fired = true; for (Consumer<T> consumer : consumers) pool.execute(() -> consumer.accept(result)); consumers.clear(); mutex.notifyAll(); } } AsyncEvent<T> addConsumer(Consumer<T> consumer); void fire(T result); boolean isFired(); @Deprecated T waitFired(); T await(); T await(long milliseconds); final void fire(); }
AsyncEvent { public void fire(T result) { synchronized (mutex) { this.result = result; fired = true; for (Consumer<T> consumer : consumers) pool.execute(() -> consumer.accept(result)); consumers.clear(); mutex.notifyAll(); } } AsyncEvent<T> addConsumer(Consumer<T> consumer); void fire(T result); boolean isFired(); @Deprecated T waitFired(); T await(); T await(long milliseconds); final void fire(); }
@Test public void matchAnonymousId() throws Exception { PrivateKey k1 = TestKeys.privateKey(0); byte[] id1 = k1.createAnonymousId(); byte[] id12 = k1.createAnonymousId(); PrivateKey k2 = TestKeys.privateKey(1); byte[] id2 = k2.createAnonymousId(); assertEquals(64, id1.length); assertEquals(64, id12.length); assertEquals(64, id2.length); assertFalse(Arrays.equals(id1, id12)); assertFalse(Arrays.equals(id1, id2)); assertFalse(Arrays.equals(id12, id2)); assertTrue(k1.matchAnonymousId(id1)); assertTrue(k1.matchAnonymousId(id12)); assertTrue(k2.matchAnonymousId(id2)); assertFalse(k2.matchAnonymousId(id1)); assertFalse(k2.matchAnonymousId(id12)); assertFalse(k1.matchAnonymousId(id2)); }
public boolean matchAnonymousId(@NonNull byte[] packedId) throws IOException { assert (packedId.length == 64); HMAC hmac = new HMAC(fingerprint()); hmac.update(packedId, 0, 32); byte[] idDigest = Arrays.copyOfRange(packedId, 32, 64); return Arrays.equals(hmac.digest(), idDigest); }
AbstractKey implements Bindable, KeyMatcher { public boolean matchAnonymousId(@NonNull byte[] packedId) throws IOException { assert (packedId.length == 64); HMAC hmac = new HMAC(fingerprint()); hmac.update(packedId, 0, 32); byte[] idDigest = Arrays.copyOfRange(packedId, 32, 64); return Arrays.equals(hmac.digest(), idDigest); } }
AbstractKey implements Bindable, KeyMatcher { public boolean matchAnonymousId(@NonNull byte[] packedId) throws IOException { assert (packedId.length == 64); HMAC hmac = new HMAC(fingerprint()); hmac.update(packedId, 0, 32); byte[] idDigest = Arrays.copyOfRange(packedId, 32, 64); return Arrays.equals(hmac.digest(), idDigest); } }
AbstractKey implements Bindable, KeyMatcher { public boolean matchAnonymousId(@NonNull byte[] packedId) throws IOException { assert (packedId.length == 64); HMAC hmac = new HMAC(fingerprint()); hmac.update(packedId, 0, 32); byte[] idDigest = Arrays.copyOfRange(packedId, 32, 64); return Arrays.equals(hmac.digest(), idDigest); } byte[] encrypt(byte[] plain); byte[] decrypt(byte[] plain); byte[] sign(InputStream input, HashType hashType); byte[] sign(byte[] input, HashType hashType); boolean verify(InputStream input, byte[] signature, HashType hashType); boolean verify(byte[] input, byte[] signature, HashType hashType); boolean verify(String input, byte[] signature, HashType hashType); KeyInfo info(); byte[] packedInfo(); byte[] pack(); String packToBase64String(); void unpack(byte[] bytes); boolean canSign(); boolean isPublic(); boolean isPrivate(); AbstractKey getPublicKey(); @Override final Binder toBinder(); @Override final T updateFrom(Binder source); static AbstractKey fromBinder(Binder binder); boolean matchType(AbstractKey other); boolean matchTag(AbstractKey other); void setTag(String tag); void setTag(byte[] tag); @Override String toString(); Capsule.KeySource asKeySource(); byte[] fingerprint(); Digest updateDigestWithKeyComponents(Digest digest); byte[] createAnonymousId(); boolean matchAnonymousId(@NonNull byte[] packedId); KeyAddress address(boolean useSha3_384, int keyMark); final KeyAddress getShortAddress(); final KeyAddress getLongAddress(); @Override boolean isMatchingKey(AbstractKey key); @Override final boolean isMatchingKeyAddress(KeyAddress other); }
AbstractKey implements Bindable, KeyMatcher { public boolean matchAnonymousId(@NonNull byte[] packedId) throws IOException { assert (packedId.length == 64); HMAC hmac = new HMAC(fingerprint()); hmac.update(packedId, 0, 32); byte[] idDigest = Arrays.copyOfRange(packedId, 32, 64); return Arrays.equals(hmac.digest(), idDigest); } byte[] encrypt(byte[] plain); byte[] decrypt(byte[] plain); byte[] sign(InputStream input, HashType hashType); byte[] sign(byte[] input, HashType hashType); boolean verify(InputStream input, byte[] signature, HashType hashType); boolean verify(byte[] input, byte[] signature, HashType hashType); boolean verify(String input, byte[] signature, HashType hashType); KeyInfo info(); byte[] packedInfo(); byte[] pack(); String packToBase64String(); void unpack(byte[] bytes); boolean canSign(); boolean isPublic(); boolean isPrivate(); AbstractKey getPublicKey(); @Override final Binder toBinder(); @Override final T updateFrom(Binder source); static AbstractKey fromBinder(Binder binder); boolean matchType(AbstractKey other); boolean matchTag(AbstractKey other); void setTag(String tag); void setTag(byte[] tag); @Override String toString(); Capsule.KeySource asKeySource(); byte[] fingerprint(); Digest updateDigestWithKeyComponents(Digest digest); byte[] createAnonymousId(); boolean matchAnonymousId(@NonNull byte[] packedId); KeyAddress address(boolean useSha3_384, int keyMark); final KeyAddress getShortAddress(); final KeyAddress getLongAddress(); @Override boolean isMatchingKey(AbstractKey key); @Override final boolean isMatchingKeyAddress(KeyAddress other); static final int FINGERPRINT_SHA256; static final int FINGERPRINT_SHA384; static final int TYPE_PRIVATE; static final int TYPE_PUBLIC; static final int TYPE_PRIVATE_PASSWORD; static final int TYPE_PRIVATE_PASSWORD_V2; }
@Test public void send() throws Exception { StreamConnector sa = new StreamConnector(); BossConnector bsc = new BossConnector(sa.getInputStream(), sa.getOutputStream()); bsc.send(Do.map("hello", "мыльня")); Map<String, Object> res = bsc.receive(); assertEquals(1, res.size()); assertEquals("мыльня", res.get("hello")); }
@Override public void send(Map<String, Object> data) throws IOException { if( closed.get() ) throw new IOException("connection closed"); bossOut.write(data); }
BossConnector extends BasicConnector implements Connector { @Override public void send(Map<String, Object> data) throws IOException { if( closed.get() ) throw new IOException("connection closed"); bossOut.write(data); } }
BossConnector extends BasicConnector implements Connector { @Override public void send(Map<String, Object> data) throws IOException { if( closed.get() ) throw new IOException("connection closed"); bossOut.write(data); } BossConnector(InputStream in, OutputStream out); }
BossConnector extends BasicConnector implements Connector { @Override public void send(Map<String, Object> data) throws IOException { if( closed.get() ) throw new IOException("connection closed"); bossOut.write(data); } BossConnector(InputStream in, OutputStream out); @Override void send(Map<String, Object> data); @Override Map<String, Object> receive(); }
BossConnector extends BasicConnector implements Connector { @Override public void send(Map<String, Object> data) throws IOException { if( closed.get() ) throw new IOException("connection closed"); bossOut.write(data); } BossConnector(InputStream in, OutputStream out); @Override void send(Map<String, Object> data); @Override Map<String, Object> receive(); }
@Test public void directLoadTest() throws Exception { StreamConnector sa = new StreamConnector(); StreamConnector sb = new StreamConnector(); Farcall fa = new Farcall(new BossConnector(sa.getInputStream(), sb.getOutputStream())); Farcall fb = new Farcall(new BossConnector(sb.getInputStream(), sa.getOutputStream())); int [] counts = new int[2]; fa.start(command -> { if (command.getName().equals("fast")) { counts[0]++; return "fast done"; } else if (command.getName().equals("slow")) { Thread.sleep(3); counts[1]++; return "slow done"; } return null; }); fb.start(); ExecutorService es = Executors.newWorkStealingPool(); ArrayList<Long> times = new ArrayList<>(); for( int rep=0; rep < 7; rep++ ) { ArrayList<Future<?>> futures = new ArrayList<>(); counts[0] = counts[1] = 0; long t = StopWatch.measure(() -> { CompletableFuture<?> cf = new CompletableFuture<>(); for (int r = 0; r < 40; r++) { futures.add(es.submit(() -> { for (int i = 0; i < 10; i++) assertEquals("fast done", fb.send("fast").waitSuccess()); return null; })); futures.add(es.submit(() -> { for (int i = 0; i < 2; i++) assertEquals("slow done", fb.send("slow").waitSuccess()); return null; })); } futures.forEach(f -> { try { f.get(); } catch (InterruptedException e) { e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } }); }); times.add(t); } long t1 = times.get(2); long t2 = times.get(times.size()-1); long mean = (t1 + t2)/2; assertThat((double) Math.abs(t2-t1) / ((double) mean), CoreMatchers.is(lessThan(0.16)) ); }
@Override public void send(Map<String, Object> data) throws IOException { if( closed.get() ) throw new IOException("connection closed"); bossOut.write(data); }
BossConnector extends BasicConnector implements Connector { @Override public void send(Map<String, Object> data) throws IOException { if( closed.get() ) throw new IOException("connection closed"); bossOut.write(data); } }
BossConnector extends BasicConnector implements Connector { @Override public void send(Map<String, Object> data) throws IOException { if( closed.get() ) throw new IOException("connection closed"); bossOut.write(data); } BossConnector(InputStream in, OutputStream out); }
BossConnector extends BasicConnector implements Connector { @Override public void send(Map<String, Object> data) throws IOException { if( closed.get() ) throw new IOException("connection closed"); bossOut.write(data); } BossConnector(InputStream in, OutputStream out); @Override void send(Map<String, Object> data); @Override Map<String, Object> receive(); }
BossConnector extends BasicConnector implements Connector { @Override public void send(Map<String, Object> data) throws IOException { if( closed.get() ) throw new IOException("connection closed"); bossOut.write(data); } BossConnector(InputStream in, OutputStream out); @Override void send(Map<String, Object> data); @Override Map<String, Object> receive(); }
@Test(timeout = 100) public void send() throws Exception { StreamConnector sa = new StreamConnector(); JsonConnector jsc = new JsonConnector(sa.getInputStream(), sa.getOutputStream()); jsc.send(Do.map("hello", "мыльня")); Map<String, Object> res = jsc.receive(); assertEquals(1, res.size()); assertEquals("мыльня", res.get("hello")); }
@Override public void send(Map<String, Object> data) throws IOException { if (closed.get()) throw new IOException("connection closed"); out.write((toJsonString(data) + "\n").getBytes()); }
JsonConnector extends BasicConnector implements Connector { @Override public void send(Map<String, Object> data) throws IOException { if (closed.get()) throw new IOException("connection closed"); out.write((toJsonString(data) + "\n").getBytes()); } }
JsonConnector extends BasicConnector implements Connector { @Override public void send(Map<String, Object> data) throws IOException { if (closed.get()) throw new IOException("connection closed"); out.write((toJsonString(data) + "\n").getBytes()); } JsonConnector(InputStream in, OutputStream out); }
JsonConnector extends BasicConnector implements Connector { @Override public void send(Map<String, Object> data) throws IOException { if (closed.get()) throw new IOException("connection closed"); out.write((toJsonString(data) + "\n").getBytes()); } JsonConnector(InputStream in, OutputStream out); @Override void send(Map<String, Object> data); @Override Map<String, Object> receive(); }
JsonConnector extends BasicConnector implements Connector { @Override public void send(Map<String, Object> data) throws IOException { if (closed.get()) throw new IOException("connection closed"); out.write((toJsonString(data) + "\n").getBytes()); } JsonConnector(InputStream in, OutputStream out); @Override void send(Map<String, Object> data); @Override Map<String, Object> receive(); }
@Test public void serialize() throws Exception { ZonedDateTime now = ZonedDateTime.now(); Binder res = DefaultBiMapper.serialize( Binder.of( "time", now, "hello", "world" ) ); assertEquals("world", res.get("hello")); assertEquals("unixtime", res.getStringOrThrow("time", "__type")); Binder restored = DefaultBiMapper.deserialize(res); assertEquals(now.truncatedTo(ChronoUnit.SECONDS), restored.get("time")); assertEquals(now.truncatedTo(ChronoUnit.SECONDS), DefaultBiMapper.deserialize(DefaultBiMapper.serialize(now))); }
public @NonNull <T> T serialize(Object x, BiSerializer serializer) { if (x instanceof String || x instanceof Number || x instanceof Boolean || x == null) return (T) x; Class<?> klass = x.getClass(); if (klass.isArray() && !(klass.getComponentType() == byte.class)) { x = Arrays.asList((Object[]) x); } if (x instanceof Collection) { return (T) ((Collection) x).stream() .map(i -> serialize(i, serializer)) .collect(Collectors.toList()); } String canonicalName = klass.getCanonicalName(); BiAdapter adapter = adapters.get(canonicalName); if (adapter == null) { if (x instanceof Map) { Binder serialized = new Binder(); ((Map)x).forEach((k,v) -> serialized.put(serialize(k),serialize(v))); return (T)serialized; } return (T) x; } Binder result = adapter.serialize(x, serializer); String tn = adapter.typeName(); result.put("__type", tn != null ? tn : canonicalName); return (T) result; }
BiMapper { public @NonNull <T> T serialize(Object x, BiSerializer serializer) { if (x instanceof String || x instanceof Number || x instanceof Boolean || x == null) return (T) x; Class<?> klass = x.getClass(); if (klass.isArray() && !(klass.getComponentType() == byte.class)) { x = Arrays.asList((Object[]) x); } if (x instanceof Collection) { return (T) ((Collection) x).stream() .map(i -> serialize(i, serializer)) .collect(Collectors.toList()); } String canonicalName = klass.getCanonicalName(); BiAdapter adapter = adapters.get(canonicalName); if (adapter == null) { if (x instanceof Map) { Binder serialized = new Binder(); ((Map)x).forEach((k,v) -> serialized.put(serialize(k),serialize(v))); return (T)serialized; } return (T) x; } Binder result = adapter.serialize(x, serializer); String tn = adapter.typeName(); result.put("__type", tn != null ? tn : canonicalName); return (T) result; } }
BiMapper { public @NonNull <T> T serialize(Object x, BiSerializer serializer) { if (x instanceof String || x instanceof Number || x instanceof Boolean || x == null) return (T) x; Class<?> klass = x.getClass(); if (klass.isArray() && !(klass.getComponentType() == byte.class)) { x = Arrays.asList((Object[]) x); } if (x instanceof Collection) { return (T) ((Collection) x).stream() .map(i -> serialize(i, serializer)) .collect(Collectors.toList()); } String canonicalName = klass.getCanonicalName(); BiAdapter adapter = adapters.get(canonicalName); if (adapter == null) { if (x instanceof Map) { Binder serialized = new Binder(); ((Map)x).forEach((k,v) -> serialized.put(serialize(k),serialize(v))); return (T)serialized; } return (T) x; } Binder result = adapter.serialize(x, serializer); String tn = adapter.typeName(); result.put("__type", tn != null ? tn : canonicalName); return (T) result; } BiMapper(); BiMapper(BiMapper parent); }
BiMapper { public @NonNull <T> T serialize(Object x, BiSerializer serializer) { if (x instanceof String || x instanceof Number || x instanceof Boolean || x == null) return (T) x; Class<?> klass = x.getClass(); if (klass.isArray() && !(klass.getComponentType() == byte.class)) { x = Arrays.asList((Object[]) x); } if (x instanceof Collection) { return (T) ((Collection) x).stream() .map(i -> serialize(i, serializer)) .collect(Collectors.toList()); } String canonicalName = klass.getCanonicalName(); BiAdapter adapter = adapters.get(canonicalName); if (adapter == null) { if (x instanceof Map) { Binder serialized = new Binder(); ((Map)x).forEach((k,v) -> serialized.put(serialize(k),serialize(v))); return (T)serialized; } return (T) x; } Binder result = adapter.serialize(x, serializer); String tn = adapter.typeName(); result.put("__type", tn != null ? tn : canonicalName); return (T) result; } BiMapper(); BiMapper(BiMapper parent); void deserializeInPlace(Map map, BiDeserializer deserializer); T deserialize(Map map, BiDeserializer deserializer); T deserialize(Map map); T deserializeObject(Object x); T deserializeObject(Object obj, BiDeserializer deserializer); @NonNull T serialize(Object x, BiSerializer serializer); @NonNull T serialize(Object x); void registerAdapter(Class<T> klass, BiAdapter adapter); boolean unregister(Class klass); void registerClass(Class<? extends BiSerializable> klass); BiSerializer newSerializer(); BiDeserializer newDeserializer(); }
BiMapper { public @NonNull <T> T serialize(Object x, BiSerializer serializer) { if (x instanceof String || x instanceof Number || x instanceof Boolean || x == null) return (T) x; Class<?> klass = x.getClass(); if (klass.isArray() && !(klass.getComponentType() == byte.class)) { x = Arrays.asList((Object[]) x); } if (x instanceof Collection) { return (T) ((Collection) x).stream() .map(i -> serialize(i, serializer)) .collect(Collectors.toList()); } String canonicalName = klass.getCanonicalName(); BiAdapter adapter = adapters.get(canonicalName); if (adapter == null) { if (x instanceof Map) { Binder serialized = new Binder(); ((Map)x).forEach((k,v) -> serialized.put(serialize(k),serialize(v))); return (T)serialized; } return (T) x; } Binder result = adapter.serialize(x, serializer); String tn = adapter.typeName(); result.put("__type", tn != null ? tn : canonicalName); return (T) result; } BiMapper(); BiMapper(BiMapper parent); void deserializeInPlace(Map map, BiDeserializer deserializer); T deserialize(Map map, BiDeserializer deserializer); T deserialize(Map map); T deserializeObject(Object x); T deserializeObject(Object obj, BiDeserializer deserializer); @NonNull T serialize(Object x, BiSerializer serializer); @NonNull T serialize(Object x); void registerAdapter(Class<T> klass, BiAdapter adapter); boolean unregister(Class klass); void registerClass(Class<? extends BiSerializable> klass); BiSerializer newSerializer(); BiDeserializer newDeserializer(); }
@Test public void testPost() throws Exception { Receiver2 receiver = new Receiver2(); informer.registerStrong(receiver); informer.post(123); assertEquals(0, Receiver2.stringCalls); assertEquals(1, Receiver2.objectCalls); assertEquals(123, receiver.lastObject); informer.post("test1"); assertEquals(2, Receiver2.stringCalls); assertEquals(2, Receiver2.objectCalls); assertEquals("test1", receiver.lastObject); assertEquals(0, Receiver2.lostCount); }
public void post(Object event) { int result; int processedCount = invokeCollection(weakInvocations, event); processedCount += invokeCollection(strongInvocations, event); if (processedCount == 0 && !(event instanceof LostEvent)) { post(new LostEvent(event)); } }
Informer { public void post(Object event) { int result; int processedCount = invokeCollection(weakInvocations, event); processedCount += invokeCollection(strongInvocations, event); if (processedCount == 0 && !(event instanceof LostEvent)) { post(new LostEvent(event)); } } }
Informer { public void post(Object event) { int result; int processedCount = invokeCollection(weakInvocations, event); processedCount += invokeCollection(strongInvocations, event); if (processedCount == 0 && !(event instanceof LostEvent)) { post(new LostEvent(event)); } } Informer(); Informer(ExceptionListener listener); }
Informer { public void post(Object event) { int result; int processedCount = invokeCollection(weakInvocations, event); processedCount += invokeCollection(strongInvocations, event); if (processedCount == 0 && !(event instanceof LostEvent)) { post(new LostEvent(event)); } } Informer(); Informer(ExceptionListener listener); void post(Object event); void postAfter(final Object event, final long millis); void registerWeak(Object subscriber); void registerStrong(Object subscriber); boolean unregister(Object subscriber); void register(Object subscriber, boolean registerWeak); }
Informer { public void post(Object event) { int result; int processedCount = invokeCollection(weakInvocations, event); processedCount += invokeCollection(strongInvocations, event); if (processedCount == 0 && !(event instanceof LostEvent)) { post(new LostEvent(event)); } } Informer(); Informer(ExceptionListener listener); void post(Object event); void postAfter(final Object event, final long millis); void registerWeak(Object subscriber); void registerStrong(Object subscriber); boolean unregister(Object subscriber); void register(Object subscriber, boolean registerWeak); }
@Test public void testPostAfter() throws Exception { Receiver1 r1 = new Receiver1(); informer.registerWeak(r1); informer.postAfter(11, 100); assertEquals(0, Receiver1.lostCount); sleep(40); assertEquals(0, Receiver1.lostCount); sleep(70); assertEquals(1, Receiver1.lostCount); }
public void postAfter(final Object event, final long millis) { new Thread(new Runnable() { @Override public void run() { try { Thread.currentThread().sleep(millis); post(event); } catch (InterruptedException e) { } } }).start(); }
Informer { public void postAfter(final Object event, final long millis) { new Thread(new Runnable() { @Override public void run() { try { Thread.currentThread().sleep(millis); post(event); } catch (InterruptedException e) { } } }).start(); } }
Informer { public void postAfter(final Object event, final long millis) { new Thread(new Runnable() { @Override public void run() { try { Thread.currentThread().sleep(millis); post(event); } catch (InterruptedException e) { } } }).start(); } Informer(); Informer(ExceptionListener listener); }
Informer { public void postAfter(final Object event, final long millis) { new Thread(new Runnable() { @Override public void run() { try { Thread.currentThread().sleep(millis); post(event); } catch (InterruptedException e) { } } }).start(); } Informer(); Informer(ExceptionListener listener); void post(Object event); void postAfter(final Object event, final long millis); void registerWeak(Object subscriber); void registerStrong(Object subscriber); boolean unregister(Object subscriber); void register(Object subscriber, boolean registerWeak); }
Informer { public void postAfter(final Object event, final long millis) { new Thread(new Runnable() { @Override public void run() { try { Thread.currentThread().sleep(millis); post(event); } catch (InterruptedException e) { } } }).start(); } Informer(); Informer(ExceptionListener listener); void post(Object event); void postAfter(final Object event, final long millis); void registerWeak(Object subscriber); void registerStrong(Object subscriber); boolean unregister(Object subscriber); void register(Object subscriber, boolean registerWeak); }
@Test public void testRegisterWeak() throws Exception { assertEquals(0, Receiver1.lostCount); informer.registerWeak(new Receiver1()); System.gc(); informer.post(11); assertEquals(0, Receiver1.lostCount); }
public void registerWeak(Object subscriber) { register(subscriber, true); }
Informer { public void registerWeak(Object subscriber) { register(subscriber, true); } }
Informer { public void registerWeak(Object subscriber) { register(subscriber, true); } Informer(); Informer(ExceptionListener listener); }
Informer { public void registerWeak(Object subscriber) { register(subscriber, true); } Informer(); Informer(ExceptionListener listener); void post(Object event); void postAfter(final Object event, final long millis); void registerWeak(Object subscriber); void registerStrong(Object subscriber); boolean unregister(Object subscriber); void register(Object subscriber, boolean registerWeak); }
Informer { public void registerWeak(Object subscriber) { register(subscriber, true); } Informer(); Informer(ExceptionListener listener); void post(Object event); void postAfter(final Object event, final long millis); void registerWeak(Object subscriber); void registerStrong(Object subscriber); boolean unregister(Object subscriber); void register(Object subscriber, boolean registerWeak); }
@Test public void testRegisterStrong() throws Exception { assertEquals(0, Receiver1.lostCount); informer.registerStrong(new Receiver1()); informer.post(11); assertEquals(1, Receiver1.lostCount); }
public void registerStrong(Object subscriber) { register(subscriber, false); }
Informer { public void registerStrong(Object subscriber) { register(subscriber, false); } }
Informer { public void registerStrong(Object subscriber) { register(subscriber, false); } Informer(); Informer(ExceptionListener listener); }
Informer { public void registerStrong(Object subscriber) { register(subscriber, false); } Informer(); Informer(ExceptionListener listener); void post(Object event); void postAfter(final Object event, final long millis); void registerWeak(Object subscriber); void registerStrong(Object subscriber); boolean unregister(Object subscriber); void register(Object subscriber, boolean registerWeak); }
Informer { public void registerStrong(Object subscriber) { register(subscriber, false); } Informer(); Informer(ExceptionListener listener); void post(Object event); void postAfter(final Object event, final long millis); void registerWeak(Object subscriber); void registerStrong(Object subscriber); boolean unregister(Object subscriber); void register(Object subscriber, boolean registerWeak); }
@Test public void testUnregister() throws Exception { assertEquals(0, Receiver1.lostCount); Receiver1 r1 = new Receiver1(); informer.registerWeak(r1); informer.unregister(r1); informer.post(11); assertEquals(0, Receiver1.lostCount); informer.registerStrong(r1); informer.unregister(r1); informer.post(11); assertEquals(0, Receiver1.lostCount); }
public boolean unregister(Object subscriber) { boolean found = (weakInvocations.remove(subscriber) != null); found = found || (strongInvocations.remove(subscriber) != null); return found; }
Informer { public boolean unregister(Object subscriber) { boolean found = (weakInvocations.remove(subscriber) != null); found = found || (strongInvocations.remove(subscriber) != null); return found; } }
Informer { public boolean unregister(Object subscriber) { boolean found = (weakInvocations.remove(subscriber) != null); found = found || (strongInvocations.remove(subscriber) != null); return found; } Informer(); Informer(ExceptionListener listener); }
Informer { public boolean unregister(Object subscriber) { boolean found = (weakInvocations.remove(subscriber) != null); found = found || (strongInvocations.remove(subscriber) != null); return found; } Informer(); Informer(ExceptionListener listener); void post(Object event); void postAfter(final Object event, final long millis); void registerWeak(Object subscriber); void registerStrong(Object subscriber); boolean unregister(Object subscriber); void register(Object subscriber, boolean registerWeak); }
Informer { public boolean unregister(Object subscriber) { boolean found = (weakInvocations.remove(subscriber) != null); found = found || (strongInvocations.remove(subscriber) != null); return found; } Informer(); Informer(ExceptionListener listener); void post(Object event); void postAfter(final Object event, final long millis); void registerWeak(Object subscriber); void registerStrong(Object subscriber); boolean unregister(Object subscriber); void register(Object subscriber, boolean registerWeak); }
@Test public void encode() { for(int i=0; i<100;i++) { byte [] src = Do.randomBytes(256+Do.randomInt(1024)); assertArrayEquals(src, Safe58.decode(Safe58.encode(src))); } }
public static String encode(byte[] input) { if (input.length == 0) { return ""; } input = copyOfRange(input, 0, input.length); int zeroCount = 0; while (zeroCount < input.length && input[zeroCount] == 0) { ++zeroCount; } byte[] temp = new byte[input.length * 2]; int j = temp.length; int startAt = zeroCount; while (startAt < input.length) { byte mod = divmod58(input, startAt); if (input[startAt] == 0) { ++startAt; } temp[--j] = (byte) ALPHABET[mod]; } while (j < temp.length && temp[j] == ALPHABET[0]) { ++j; } while (--zeroCount >= 0) { temp[--j] = (byte) ALPHABET[0]; } byte[] output = copyOfRange(temp, j, temp.length); return new String(output); }
Safe58 { public static String encode(byte[] input) { if (input.length == 0) { return ""; } input = copyOfRange(input, 0, input.length); int zeroCount = 0; while (zeroCount < input.length && input[zeroCount] == 0) { ++zeroCount; } byte[] temp = new byte[input.length * 2]; int j = temp.length; int startAt = zeroCount; while (startAt < input.length) { byte mod = divmod58(input, startAt); if (input[startAt] == 0) { ++startAt; } temp[--j] = (byte) ALPHABET[mod]; } while (j < temp.length && temp[j] == ALPHABET[0]) { ++j; } while (--zeroCount >= 0) { temp[--j] = (byte) ALPHABET[0]; } byte[] output = copyOfRange(temp, j, temp.length); return new String(output); } }
Safe58 { public static String encode(byte[] input) { if (input.length == 0) { return ""; } input = copyOfRange(input, 0, input.length); int zeroCount = 0; while (zeroCount < input.length && input[zeroCount] == 0) { ++zeroCount; } byte[] temp = new byte[input.length * 2]; int j = temp.length; int startAt = zeroCount; while (startAt < input.length) { byte mod = divmod58(input, startAt); if (input[startAt] == 0) { ++startAt; } temp[--j] = (byte) ALPHABET[mod]; } while (j < temp.length && temp[j] == ALPHABET[0]) { ++j; } while (--zeroCount >= 0) { temp[--j] = (byte) ALPHABET[0]; } byte[] output = copyOfRange(temp, j, temp.length); return new String(output); } }
Safe58 { public static String encode(byte[] input) { if (input.length == 0) { return ""; } input = copyOfRange(input, 0, input.length); int zeroCount = 0; while (zeroCount < input.length && input[zeroCount] == 0) { ++zeroCount; } byte[] temp = new byte[input.length * 2]; int j = temp.length; int startAt = zeroCount; while (startAt < input.length) { byte mod = divmod58(input, startAt); if (input[startAt] == 0) { ++startAt; } temp[--j] = (byte) ALPHABET[mod]; } while (j < temp.length && temp[j] == ALPHABET[0]) { ++j; } while (--zeroCount >= 0) { temp[--j] = (byte) ALPHABET[0]; } byte[] output = copyOfRange(temp, j, temp.length); return new String(output); } static String encode(byte[] input); static byte[] decode(String input); static byte[] decode(String input, boolean strict); }
Safe58 { public static String encode(byte[] input) { if (input.length == 0) { return ""; } input = copyOfRange(input, 0, input.length); int zeroCount = 0; while (zeroCount < input.length && input[zeroCount] == 0) { ++zeroCount; } byte[] temp = new byte[input.length * 2]; int j = temp.length; int startAt = zeroCount; while (startAt < input.length) { byte mod = divmod58(input, startAt); if (input[startAt] == 0) { ++startAt; } temp[--j] = (byte) ALPHABET[mod]; } while (j < temp.length && temp[j] == ALPHABET[0]) { ++j; } while (--zeroCount >= 0) { temp[--j] = (byte) ALPHABET[0]; } byte[] output = copyOfRange(temp, j, temp.length); return new String(output); } static String encode(byte[] input); static byte[] decode(String input); static byte[] decode(String input, boolean strict); }