Merge pull request #516 from agonyforge/liquidity-error-handling

Liquidity error handling

Author: scionaltera

src/main/java/com/agonyforge/arbitrader/service/LiquidityException.java

@@ -0,0 +1,10 @@
+package com.agonyforge.arbitrader.service;
+
+/**
+ * Thrown when an exchange has too little liquidity for us to place the order we want.
+ */
+public class LiquidityException extends RuntimeException {
+    public LiquidityException(String message) {
+        super(message);
+    }
+}

src/main/java/com/agonyforge/arbitrader/service/TradingService.java

@@ -226,8 +226,8 @@ private void enterPosition(Spread spread) {
         try {
             longLimitPrice = getLimitPrice(spread.getLongExchange(), spread.getCurrencyPair(), tradeVolume.getLongVolume(), Order.OrderType.ASK);
             shortLimitPrice = getLimitPrice(spread.getShortExchange(), spread.getCurrencyPair(), tradeVolume.getShortVolume(), Order.OrderType.BID);
-        } catch (ExchangeException e) {
-            LOGGER.warn("Failed to fetch order books for {}/{} and currency {}/{} to compute entry prices: {}",
+        } catch (IOException | ExchangeException e) {
+            LOGGER.error("Failed to fetch order books for {}/{} and currency {}/{} to compute entry prices: {}",
                 longExchangeName,
                 spread.getShortExchange().getDefaultExchangeSpecification().getExchangeName(),
                 spread.getCurrencyPair().base,
@@ -456,7 +456,7 @@ private void exitPosition(Spread spread) {
         try {
             longLimitPrice = getLimitPrice(spread.getLongExchange(), spread.getCurrencyPair(), tradeVolume.getLongVolume(), Order.OrderType.BID);
             shortLimitPrice = getLimitPrice(spread.getShortExchange(), spread.getCurrencyPair(), tradeVolume.getShortVolume(), Order.OrderType.ASK);
-        } catch (ExchangeException e) {
+        } catch (IOException | ExchangeException e) {
             LOGGER.warn("Failed to fetch order books (on active position) for {}/{} and currency {}/{} to compute entry prices: {}",
                 longExchangeName,
                 spread.getShortExchange().getDefaultExchangeSpecification().getExchangeName(),
@@ -941,35 +941,35 @@ BigDecimal getVolumeForOrder(Exchange exchange, CurrencyPair currencyPair, Strin
      * @param orderType Are we buying or selling? Use the bid or ask price?
      * @return The more accurate price for this order.
      */
-    BigDecimal getLimitPrice(Exchange exchange, CurrencyPair rawCurrencyPair, BigDecimal allowedVolume, Order.OrderType orderType) {
+    BigDecimal getLimitPrice(Exchange exchange, CurrencyPair rawCurrencyPair, BigDecimal allowedVolume, Order.OrderType orderType) throws IOException {
         CurrencyPair currencyPair = exchangeService.convertExchangePair(exchange, rawCurrencyPair);
+        OrderBook orderBook = exchange.getMarketDataService().getOrderBook(currencyPair);
+        List<LimitOrder> orders = orderType.equals(Order.OrderType.ASK) ? orderBook.getAsks() : orderBook.getBids();
+        BigDecimal price;
+        BigDecimal volume = BigDecimal.ZERO;
 
-        try {
-            OrderBook orderBook = exchange.getMarketDataService().getOrderBook(currencyPair);
-            List<LimitOrder> orders = orderType.equals(Order.OrderType.ASK) ? orderBook.getAsks() : orderBook.getBids();
-            BigDecimal price;
-            BigDecimal volume = BigDecimal.ZERO;
-
-            // Walk through orders, ordered by price, until we satisfy all the volume we need.
-            // Return the price of the last order we see.
-            //
-            // If we set our limit order at this price (without waiting too long) it is very likely to fill
-            // because we know the exchange has enough currency available to fill it at this or a better price.
-            for (LimitOrder order : orders) {
-                price = order.getLimitPrice();
+        // Walk through orders, ordered by price, until we satisfy all the volume we need.
+        // Return the price of the last order we see.
+        //
+        // If we set our limit order at this price (without waiting too long) it is very likely to fill
+        // because we know the exchange has enough currency available to fill it at this or a better price.
+        for (LimitOrder order : orders) {
+            price = order.getLimitPrice();
+
+            if (order.getRemainingAmount() == null || BigDecimal.ZERO.compareTo(order.getRemainingAmount()) == 0) {
+                volume = volume.add(order.getOriginalAmount());
+            } else{
                 volume = volume.add(order.getRemainingAmount());
+            }
 
-                if (volume.compareTo(allowedVolume) > 0) {
-                    int scale = computePriceScale(exchange, currencyPair);
+            if (volume.compareTo(allowedVolume) > 0) {
+                int scale = computePriceScale(exchange, currencyPair);
 
-                    return price.setScale(scale, RoundingMode.HALF_EVEN);
-                }
+                return price.setScale(scale, RoundingMode.HALF_EVEN);
             }
-        } catch (IOException e) {
-            LOGGER.error("IOE fetching {} {} order volume", exchange.getExchangeSpecification().getExchangeName(), currencyPair, e);
         }
 
-        throw new RuntimeException("Not enough liquidity on exchange to fulfill required volume!");
+        throw new LiquidityException("Not enough liquidity on exchange to fulfill required volume!");
     }
 
     /**

src/test/java/com/agonyforge/arbitrader/service/TradingServiceTest.java

@@ -201,7 +201,7 @@ public void testGetVolumeFallbackToDefaultIOException() throws IOException {
 
     // the best price point has enough volume to fill my order
     @Test
-    public void testLimitPriceLongSufficientVolume() {
+    public void testLimitPriceLongSufficientVolume() throws IOException {
         when(exchangeService.convertExchangePair(any(Exchange.class), any(CurrencyPair.class)))
             .thenReturn(currencyPair);
 
@@ -213,7 +213,7 @@ public void testLimitPriceLongSufficientVolume() {
 
     // the best price point has enough volume to fill my order
     @Test
-    public void testLimitPriceShortSufficientVolume() {
+    public void testLimitPriceShortSufficientVolume() throws IOException {
         when(exchangeService.convertExchangePair(any(Exchange.class), any(CurrencyPair.class)))
             .thenReturn(currencyPair);
 
@@ -225,7 +225,7 @@ public void testLimitPriceShortSufficientVolume() {
 
     // the best price point isn't big enough to fill my order alone, so the price will slip
     @Test
-    public void testLimitPriceLongInsufficientVolume() {
+    public void testLimitPriceLongInsufficientVolume() throws IOException {
         when(exchangeService.convertExchangePair(any(Exchange.class), any(CurrencyPair.class)))
             .thenReturn(currencyPair);
         BigDecimal allowedVolume = new BigDecimal("11.00");
@@ -236,7 +236,7 @@ public void testLimitPriceLongInsufficientVolume() {
 
     // the best price point isn't big enough to fill my order alone, so the price will slip
     @Test
-    public void testLimitPriceShortInsufficientVolume() {
+    public void testLimitPriceShortInsufficientVolume() throws IOException {
         when(exchangeService.convertExchangePair(any(Exchange.class), any(CurrencyPair.class)))
             .thenReturn(currencyPair);
         BigDecimal allowedVolume = new BigDecimal("11.00");
@@ -247,15 +247,15 @@ public void testLimitPriceShortInsufficientVolume() {
 
     // the exchange doesn't have enough volume to fill my gigantic order
     @Test(expected = RuntimeException.class)
-    public void testLimitPriceLongInsufficientLiquidity() {
+    public void testLimitPriceLongInsufficientLiquidity() throws IOException {
         BigDecimal allowedVolume = new BigDecimal(10001);
 
         tradingService.getLimitPrice(longExchange, currencyPair, allowedVolume, Order.OrderType.ASK);
     }
 
     // the exchange doesn't have enough volume to fill my gigantic order
     @Test(expected = RuntimeException.class)
-    public void testLimitPriceShortInsufficientLiquidity() {
+    public void testLimitPriceShortInsufficientLiquidity() throws IOException {
         BigDecimal allowedVolume = new BigDecimal(10001);
 
         tradingService.getLimitPrice(longExchange, currencyPair, allowedVolume, Order.OrderType.BID);