import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class PowerDNSPipeTest
{
  public static void main(String[] args) throws Exception
  {
    BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

    readIntro(reader);

    String line;
    while((line = reader.readLine()) != null)
    {
      processLine(line);
    }
  }

  private static void processLine(String line)
  {
    String values[] = line.split("\t");

    if(values.length == 6)
    {
      // Testing any a response to the ANY or A record request
      if("ANY".equalsIgnoreCase(values[3]) || "A".equalsIgnoreCase(values[3]))
      {
        System.out.println("DATA\t" + values[1] + "\tIN\tA\t0\t1800\t127.0.0.5");
      }
    }
    else
    {
      System.out.println("LOG\tPowerDNS sent unpareable string");
      System.out.println("FAIL");
    }

    System.out.println("END");
    System.out.flush();
  }

  private static void readIntro(BufferedReader reader) throws IOException
  {
    String line = reader.readLine();
    if(line != null)
    {
      String values[] = line.split("\t");
      if(values.length == 2 && "HELO".equals(values[0]) && "1".equals(values[1]))
      {
        System.out.println("OK\tBackend starting");
        return;
      }
    }

    System.out.println("FAIL");
    System.out.flush();
    System.exit(-1);
  }
}

import java.net.ServerSocket;
import java.net.Socket;
import java.io.*;
import java.util.concurrent.PriorityBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class PowerDNSServerTest
{
  public static void main(String[] args) throws Exception
  {
    PriorityBlockingQueue<Runnable> queue = new PriorityBlockingQueue<Runnable>();
    ThreadPoolExecutor threadPool = new ThreadPoolExecutor(5, 30, 30, TimeUnit.SECONDS, queue);

    ServerSocket serverSocket = new ServerSocket(4444);

    while(true)
    {
      threadPool.execute(new PowerDNSServerClientThread(serverSocket.accept()));
    }
  }

  private static class PowerDNSServerClientThread implements Runnable
  {
    private Socket clientSocket;

    public PowerDNSServerClientThread(Socket clientSocket)
    {
      this.clientSocket = clientSocket;
    }

    public void run()
    {
      try
      {
        BufferedReader input = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
        BufferedWriter output = new BufferedWriter(new OutputStreamWriter(clientSocket.getOutputStream()));

        String command = input.readLine();
        System.err.println("[" + Thread.currentThread().getName() + "] Received: " + command);

        String values[] = command.split("\t");

        if(values.length == 6)
        {
          // Testing any a response to the ANY or A record request
          if("ANY".equalsIgnoreCase(values[3]) || "A".equalsIgnoreCase(values[3]))
          {
            output.write("DATA\t" + values[1] + "\tIN\tA\t0\t1800\t127.0.0.5\n");
          }
        }
        else
        {
          output.write("LOG\tPowerDNS sent unpareable string\n");
          output.write("FAIL\n");
        }

        output.write("END\n");
        output.flush();

        output.close();
        input.close();

        clientSocket.close();
      }
      catch (IOException e)
      {
        e.printStackTrace();
      }
    }
  }
}

public static ConvolveOp getLinearBlurOp(int width, int height)
  {
    float[] data = new float[width * height];
    float value = 1.0f / (float) (width * height);
    for (int i = 0; i < data.length; i++)
    {
      data[i] = value;
    }
    return new ConvolveOp(new Kernel(width, height, data));
  }

  public static BufferedImage buildChartDropShadow(BufferedImage chartImage, int padding)
  {
    return buildChartDropShadow(chartImage, padding, null);
  }

  public static BufferedImage buildChartDropShadow(BufferedImage chartImage, int padding, Color backgroundColor)
  {
    BufferedImage shadow = new BufferedImage(chartImage.getWidth() + (padding*2), chartImage.getHeight() + (padding*2), BufferedImage.TYPE_INT_ARGB);
    Graphics2D shadowCanvas = (Graphics2D) shadow.getGraphics();
    shadowCanvas.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    shadowCanvas.setColor(Color.white);
    shadowCanvas.fillRect(0, 0, chartImage.getWidth() + (padding*2), chartImage.getHeight() + (padding*2));
    shadowCanvas.setPaint(Color.black);
    shadowCanvas.fillRoundRect(padding, padding, chartImage.getWidth(), chartImage.getHeight(), 20, 20);
    shadowCanvas.dispose();

    BufferedImage finalImage = new BufferedImage(chartImage.getWidth() + (padding*2), chartImage.getHeight() + (padding*2), BufferedImage.TYPE_INT_ARGB);
    Graphics2D finalCanvas = (Graphics2D) finalImage.getGraphics();
    finalCanvas.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    finalCanvas.setColor(backgroundColor == null ? Color.white :  backgroundColor);
    finalCanvas.fillRect(0, 0, chartImage.getWidth() + (padding*2), chartImage.getHeight() + (padding*2));
    finalCanvas.drawImage(shadow, getLinearBlurOp(10, 10), 2, 2);

    finalCanvas.setPaint(new GradientPaint(0.0f, 0.0f, new Color(0xdc, 0xe5, 0xf4), 0.0f, chartImage.getHeight() * 0.2f, new Color(0xff, 0xff, 0xff)));
    finalCanvas.fillRoundRect(padding, padding, chartImage.getWidth(), chartImage.getHeight(), 20, 20);
    finalCanvas.drawImage(chartImage, null, padding, padding);
    finalCanvas.dispose();

    return finalImage;
  }

  /**
   * Testing area
   *
   * @param args
   * @throws Exception
   */
  public static void main(String[] args) throws Exception
  {
    DefaultCategoryDataset dataset = new DefaultCategoryDataset();

    JFreeChart jFreeChart = ChartFactory.createBarChart(null, null, "Test", dataset, PlotOrientation.VERTICAL, true, false, false);
    jFreeChart.setBackgroundPaint(new Color(255,255,255,0));
    jFreeChart.setPadding(new RectangleInsets(10, 5, 5, 5));

    CategoryPlot plot = (CategoryPlot) jFreeChart.getPlot();
    BarRenderer renderer = (BarRenderer) plot.getRenderer();
    renderer.setDrawBarOutline(false);

    renderer.setSeriesPaint(0, new Color(0×25, 0×64, 0xc1));
    renderer.setSeriesPaint(1, new Color(0xc7, 0×38, 0×00));
    renderer.setSeriesPaint(2, new Color(0×46, 0xb1, 0xc2));
    renderer.setSeriesPaint(3, new Color(0×76, 0xc8, 0x2d));

    NumberAxis numberaxis = (NumberAxis)plot.getRangeAxis();
    DecimalFormat currencyFormat = (DecimalFormat) NumberFormat.getCurrencyInstance();
    currencyFormat.setMaximumFractionDigits(0);
    numberaxis.setNumberFormatOverride(currencyFormat);

    jFreeChart.getLegend().setHorizontalAlignment(HorizontalAlignment.LEFT);
    jFreeChart.getLegend().setPosition(RectangleEdge.RIGHT);
    jFreeChart.getLegend().setBorder(0.0, 0.0, 0.0, 0.0);
    jFreeChart.getLegend().setBackgroundPaint(new Color(255,255,255,0));

    dataset.addValue(new BigDecimal(10.0), "Value1", "Sample");
    dataset.addValue(new BigDecimal(13.0), "Value2", "Sample");
    dataset.addValue(new BigDecimal(18.0), "Value3", "Sample");

    try
    {
      int padding = 10;
      int width = 500;
      int height = 300;
      ImageIO.write(GraphicsUtil.buildChartDropShadow(jFreeChart.createBufferedImage(width-(padding*2), height-(padding*2)), padding), "png", new FileOutputStream("/tmp/test.png"));
    }
    catch (IOException e)
    {
      throw new SystemException(e.getMessage(), e);
    }
}

package net.ioncannon;

import org.apache.commons.net.telnet.TelnetClient;
import org.apache.commons.net.SocketFactory;

import java.io.IOException;
import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.net.*;

public class TelAllTestMain
{
  public static void main(String[] args) throws IOException
  {
    TelnetClient telnetClient = new TelnetClient();
    telnetClient.setSocketFactory(new TimeoutSockectFactory());
    telnetClient.setDefaultTimeout(1000);
    telnetClient.connect("localhost");
    telnetClient.setSoTimeout(1000);
    telnetClient.setSoLinger(true, 1000);

    BufferedReader reader = new BufferedReader(new InputStreamReader(telnetClient.getInputStream()));

    StringBuffer stringBuffer = new StringBuffer();
    try
    {
      char buffer[] = new char[1024];
      int size = -1;
      while((size = reader.read(buffer)) != -1)
      {
        stringBuffer.append(buffer, 0, size);
        if(stringBuffer.toString().endsWith("something"))
        {
          System.err.println("Found the string…");
          break;
        }
      }
    }
    catch (Exception e)
    {
      System.err.println("Didn't find the string…");
    }      

    telnetClient.disconnect();
  }

  private static class TimeoutSockectFactory implements SocketFactory
  {
    public Socket createSocket(String hostname, int port) throws IOException
    {
      Socket socket = new Socket();
      socket.connect(new InetSocketAddress(hostname, port), 1000);
      return socket;
    }

    public Socket createSocket(InetAddress hostAddress, int port) throws IOException
    {
      Socket socket = new Socket();
      socket.connect(new InetSocketAddress(hostAddress, port), 1000);
      return socket;
    }

    public Socket createSocket(String remoteHost, int remotePort, InetAddress localAddress, int localPort) throws IOException
    {
      return new Socket();
    }

    public Socket createSocket(InetAddress remoteAddress, int remotePort, InetAddress localAddress, int localPort) throws IOException
    {
      return new Socket();
    }

    public ServerSocket createServerSocket(int port) throws IOException
    {
      return new ServerSocket();
    }

    public ServerSocket createServerSocket(int port, int backlog) throws IOException
    {
      return new ServerSocket();
    }

    public ServerSocket createServerSocket(int port, int backlog, InetAddress bindAddress) throws IOException
    {
      return new ServerSocket();
    }
  }
}

import org.xbill.DNS.*;

import java.util.Iterator;
import java.net.UnknownHostException;

/**
 */
public class ExampleOne
{
  public static void main(String[] args) throws UnknownHostException, TextParseException
  {
    String ipAddress = "2.0.0.127";
    String dnsblDomain = "sbl-xbl.spamhaus.org";

    Lookup lookup = new Lookup(ipAddress + "." + dnsblDomain, Type.ANY);
    Resolver resolver = new SimpleResolver();
    lookup.setResolver(resolver);
    lookup.setCache(null);
    Record[] records = lookup.run();
    if(lookup.getResult() == Lookup.SUCCESSFUL)
    {
      String responseMessage = null;
      String listingType = null;
      for (int i = 0; i < records.length; i++)
      {
        if(records[i] instanceof TXTRecord)
        {
          TXTRecord txt = (TXTRecord) records[i];
          for(Iterator j = txt.getStrings().iterator(); j.hasNext();)
          {
            responseMessage += (String)j.next();
          }
        }
        else if(records[i] instanceof ARecord)
        {
          listingType = ((ARecord)records[i]).getAddress().getHostAddress();
        }
      }

      System.err.println("Found!");
      System.err.println("Response Message: " + responseMessage);
      System.err.println("Listing Type: " + listingType);
    }
    else if(lookup.getResult() == Lookup.HOST_NOT_FOUND)
    {
      System.err.println("Not found.");
    }
    else
    {
      System.err.println("Error!");
    }
  }
}

import org.apache.log4j.Logger;

import java.net.Socket;
import java.io.*;
import java.util.Map;
import java.util.HashMap;

public class RequestThread implements Runnable
{
  private static final Logger log = Logger.getLogger(RequestThread.class);

  private Socket requestSocket = null;

  public RequestThread(Socket requestSocket)
  {
    this.requestSocket = requestSocket;
  }

  public void run()
  {
    try
    {
      BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(requestSocket.getInputStream()));
      BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(requestSocket.getOutputStream()));

      // do some processing…

      bufferedReader.close();
      bufferedWriter.close();
    }
    catch (IOException e)
    {
      log.error("Error communicating with client: " + e.getMessage(), e);
    }
  }
}

import java.net.ServerSocket;
import java.net.Socket;
import java.io.IOException;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;

import org.apache.log4j.Logger;

public class NetworkServer
{
  private static final Logger log = Logger.getLogger(NetworkServer.class);
  private static final int THREAD_COUNT = 10;
  private static final short LISTEN_PORT = 3434;

  private ServerSocket serverSocket = null;
  private boolean shutdown = false;

  private final ThreadPoolExecutor pool = new ThreadPoolExecutor(THREAD_COUNT, THREAD_COUNT, 10, TimeUnit.SECONDS, new LinkedBlockingQueue());

  public NetworkServer() throws IOException
  {
    try
    {
      serverSocket = new ServerSocket(LISTEN_PORT);
    }
    catch (IOException e)
    {
      pool.shutdownNow();
      throw e;
    }
import java.net.ServerSocket;
import java.net.Socket;
import java.io.IOException;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;

import org.apache.log4j.Logger;

public class NetworkServer
{
  private static final Logger log = Logger.getLogger(NetworkServer.class);
  private static final int THREAD_COUNT = 10;
  private static final short LISTEN_PORT = 3434;

  private ServerSocket serverSocket = null;
  private boolean shutdown = false;

  private final ThreadPoolExecutor pool = new ThreadPoolExecutor(THREAD_COUNT, THREAD_COUNT, 10, TimeUnit.SECONDS, new LinkedBlockingQueue());

  public NetworkServer() throws IOException
  {
    try
    {
      serverSocket = new ServerSocket(LISTEN_PORT);
    }
    catch (IOException e)
    {
      pool.shutdownNow();
      throw e;
    }
  }

  public void serve()
  {
    try
    {
      while(!shutdown)
      {
        pool.execute(new RequestThread(serverSocket.accept()));
      }
    }
    catch (Exception e)
    {
      log.error(“Exception while starting request: “ + e.getMessage(), e);
    }
  }

  public void shutdown()
  {
    this.shutdown = true;
    pool.shutdownNow();
    makeFinalConnection();
  }

  private void makeFinalConnection()
  {
    try
    {
      Socket clientSocket = new Socket(“localhost”, LISTEN_PORT);
      clientSocket.close();
    }
    catch (Exception e)
    {
    }
  }
}

  }

  public void serve()
  {
    try
    {
      while(!shutdown)
      {
        pool.execute(new RequestThread(serverSocket.accept()));
      }
    }
    catch (Exception e)
    {
      log.error("Exception while starting request: " + e.getMessage(), e);
    }
  }

  public void shutdown()
  {
    this.shutdown = true;
    pool.shutdownNow();
    makeFinalConnection();
  }

  private void makeFinalConnection()
  {
    try
    {
      Socket clientSocket = new Socket("localhost", LISTEN_PORT);
      clientSocket.close();
    }
    catch (Exception e)
    {
    }
  }
}

import EDU.oswego.cs.dl.util.concurrent.PooledExecutor;
import EDU.oswego.cs.dl.util.concurrent.LinkedQueue;

import java.net.ServerSocket;
import java.net.Socket;
import java.io.IOException;

import org.apache.log4j.Logger;

public class NetworkServer
{
  private static final Logger log = Logger.getLogger(NetworkServer.class);
  private static final int THREAD_COUNT = 10;
  private static final short LISTEN_PORT = 3434;

  private ServerSocket serverSocket = null;
  private boolean shutdown = false;

  private final PooledExecutor pool = new PooledExecutor(new LinkedQueue());

  public NetworkServer() throws IOException
  {
    pool.setKeepAliveTime(-1);
    pool.createThreads(THEAD_COUNT);

    try
    {
      serverSocket = new ServerSocket(LISTEN_PORT);
    }
    catch (IOException e)
    {
      pool.shutdownNow();
      throw e;
    }
  }

  public void serve()
  {
    try
    {
      while(!shutdown)
      {
        pool.execute(new RequestThread(serverSocket.accept()));
      }
    }
    catch (Exception e)
    {
      log.error("Exception while starting request: " + e.getMessage(), e);
    }
  }

  public void shutdown()
  {
    this.shutdown = true;
    pool.drain();
    pool.shutdownNow();
    makeFinalConnection();
  }

  private void makeFinalConnection()
  {
    try
    {
      Socket clientSocket = new Socket("localhost",LISTEN_PORT);
      clientSocket.close();
    }
    }
    catch (Exception e)
    {
    }
  }
}

public static void doBatchInsert(List aLargeList, Connection connection) throws SQLException
{
  // You have to turn auto commit off, if you are doing a large set of inserts and updates you are probably doing this already.
  connection.setAutoCommit(false);

  PreparedStatement preparedStatement = connection.prepareStatement("insert into a_table(a_col) values (?)");
  // This is the magic. Set the number of statements to allow in one batch
  ((OraclePreparedStatement)ps).setExecuteBatch (10);

  int count = 0;
  for(Iterator i=aLargeList.iterator(); i.hasNext(); count++)
  {
    YourData yourData = (YourData)i.next();

    preparedStatement.setInt(1, yourData.getAnInt());
    preparedStatement.executeUpdate();

    if(count % 10 == 0)
    {
      // Send all currently queued statements
      ((OraclePreparedStatement)preparedStatement).sendBatch();
      connection.commit();
    }
  }

  ((OraclePreparedStatement)preparedStatement).sendBatch();
  connection.commit();
  preapredStatement.close();
}