/* * 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.index; import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.util.HashMap; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentMap; import org.apache.log4j.Logger; import com.flaptor.util.Execute; import com.google.common.base.Preconditions; import com.google.common.collect.Maps; public class BasicPromoter extends AbstractPromoter { private static final Logger logger = Logger.getLogger(Execute.whoAmI()); private static final String MAIN_FILE_NAME = "promoter"; private final ConcurrentMap<String, String> storage; private final File backupDir; /** * Constructor. * Creates an empty Promoter. * @param backupDir the directory to wich the data stored in this Scorer shall be * @param load if true, the promoter is generated from it's serialized version. * persisted. */ @SuppressWarnings("unchecked") public BasicPromoter(File backupDir, boolean load) throws IOException { checkDirArgument(backupDir); this.backupDir = backupDir; if (!load) { storage = new ConcurrentHashMap<String, String>(); } else { File f = new File(this.backupDir, MAIN_FILE_NAME); ObjectInputStream is = null; try { is = new ObjectInputStream(new BufferedInputStream(new FileInputStream(f))); try { storage = (ConcurrentMap<String, String>) is.readObject(); } catch (ClassNotFoundException e) { throw new IllegalStateException(e); } } finally { Execute.close(is); } } } private static void checkDirArgument(File backupDir) { Preconditions.checkNotNull(backupDir); if (!backupDir.canRead()) { String s = "Don't have read permission over the backup directory(" + backupDir.getAbsolutePath() + ")."; logger.error(s); throw new IllegalArgumentException(s); } if (!backupDir.canWrite()) { String s = "Don't have write permission over the backup directory(" + backupDir.getAbsolutePath() + ")."; logger.error(s); throw new IllegalArgumentException(s); } } @Override public void promoteResult(String docId, String queryStr) { Preconditions.checkNotNull(docId); Preconditions.checkNotNull(queryStr); storage.put(queryStr, docId); } @Override public String getPromotedDocId(String queryStr) { return storage.get(queryStr); } private synchronized void syncToDisk() throws IOException { logger.info("Starting info dump to disk."); File f = new File(backupDir, MAIN_FILE_NAME); ObjectOutputStream os = null; try { os = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream(f))); os.writeObject(storage); os.flush(); } finally { Execute.close(os); } logger.info("Dump to disk finished"); } @Override public void dump() throws IOException { syncToDisk(); } @Override public Map<String, String> getStats() { HashMap<String, String> stats = Maps.newHashMap(); stats.put("basic_promoter_count", String.valueOf(storage.size())); return stats; } }