/* * Copyright (c) 2011 LinkedIn, Inc * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ package com.flaptor.indextank.storage; import java.io.File; import java.io.IOException; import org.apache.commons.cli.CommandLine; import org.apache.commons.cli.CommandLineParser; import org.apache.commons.cli.HelpFormatter; import org.apache.commons.cli.Option; import org.apache.commons.cli.OptionBuilder; import org.apache.commons.cli.Options; import org.apache.commons.cli.ParseException; import org.apache.commons.cli.PosixParser; import org.apache.thrift.TException; import org.apache.thrift.TProcessor; import org.apache.thrift.transport.TTransportException; import com.flaptor.indextank.rpc.LogBatch; import com.flaptor.indextank.rpc.LogRecord; import com.flaptor.indextank.rpc.LogWriter; import com.flaptor.indextank.util.FormatLogger; import com.flaptor.indextank.util.ThriftServerThread; import com.flaptor.util.Execute; import com.google.common.base.Preconditions; public class LogWriterServer implements LogWriter.Iface { static final FormatLogger logger = new FormatLogger(); static final FormatLogger alertLogger = FormatLogger.getAlertsLogger(); protected RawLog liveLog; protected final int port; protected LogRoot root; private final boolean testMode; /** * Constructor for tests only. Used to run cycles without actually starting the server. * @throws IOException */ LogWriterServer(LogRoot root, int liveSegmentSize, boolean testMode) throws IOException { Preconditions.checkArgument(testMode, "This constructor is only intended for test mode"); this.testMode = testMode; this.port = -1; this.liveLog = new RawLog(root, liveSegmentSize); this.root = root; if (!root.lockComponent("writer")) { throw new RuntimeException("Unable to get lock, there's another server running writing to this log."); } } private LogWriterServer(int port) throws IOException { this(LogRoot.DEFAULT_PATH, port); } private LogWriterServer(File path, int port) throws IOException { this.port = port; this.root = new LogRoot(path, LogRoot.DEFAULT_READING_PAGE_SIZE); this.liveLog = new RawLog(root, RawLog.DEFAULT_SEGMENT_SIZE); this.testMode = false; if (!root.lockComponent("writer")) { throw new RuntimeException("Unable to get lock, there's another server running writing to this log."); } } @Override public void send_batch(LogBatch batch) throws TException { for (LogRecord record : batch.get_records()) { try { liveLog.write(record); } catch (IOException e) { alertLogger.error(e, "Unable to write batch of %d records.", batch.get_records_size()); throw new RuntimeException(e); } } if (testMode) { liveLog.flush(); } } public void start(){ Runtime.getRuntime().addShutdownHook(new Thread() { @Override public void run() { try { logger.info("Flushing live log to disk"); liveLog.flush(); logger.info("Successfully flushed to disk"); } catch (TTransportException e) { } } }); TProcessor processor = new LogWriter.Processor(LogWriterServer.this); ThriftServerThread.forProcessor(processor, "LogWriterServer", port).start(); new FlushEverySecond().start(); } @SuppressWarnings("static-access") private static Options getOptions(){ Option port = OptionBuilder .withArgName("port") .hasArg() .withDescription("Server Port") .withLongOpt("port") .create("p"); Option path = OptionBuilder .withArgName("path") .hasArg() .withDescription("Logs Path") .withLongOpt("path") .isRequired(false) .create("f"); Option help = OptionBuilder .withDescription("Displays this help") .withLongOpt("help") .create("h"); Options options = new Options(); options.addOption(port); options.addOption(path); options.addOption(help); return options; } private static void printHelp(Options options, String error) { if (null != error) { System.out.println("Invalid usage: " + error); } HelpFormatter formatter = new HelpFormatter(); formatter.printHelp("LogWriterServer [options]", options); } public static void main(String[] args) throws IOException, InterruptedException{ // create the parser CommandLineParser parser = new PosixParser(); int port; LogWriterServer server; try { // parse the command line arguments CommandLine line = parser.parse( getOptions(), args ); if (line.hasOption("help")) { printHelp(getOptions(), null); System.exit(1); return; } String val = null; val = line.getOptionValue("port", null); if (null != val) { port = Integer.valueOf(val); } else { printHelp(getOptions(), "Must specify a server port"); System.exit(1); return; } String path = null; path = line.getOptionValue("path", null); if (null != path) { server = new LogWriterServer(new File(path), port); } else { server = new LogWriterServer(port); } } catch( ParseException exp ) { printHelp(getOptions(),exp.getMessage()); System.exit(1); return; } server.start(); } private class FlushEverySecond extends Thread { @Override public void run() { while (true) { try { Execute.sleep(1000); liveLog.flush(); } catch (Throwable t) { alertLogger.error(t, "Failed while flushing!!!"); } } } } }