Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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 org.apache.accumulo.core.client.mock; import java.io.DataInputStream; import java.io.IOException; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; import java.util.HashMap; import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Map.Entry; import java.util.Set; import java.util.SortedSet; import java.util.TreeSet; import org.apache.accumulo.core.client.AccumuloException; import org.apache.accumulo.core.client.AccumuloSecurityException; import org.apache.accumulo.core.client.IteratorSetting; import org.apache.accumulo.core.client.NamespaceNotFoundException; import org.apache.accumulo.core.client.TableExistsException; import org.apache.accumulo.core.client.TableNotFoundException; import org.apache.accumulo.core.client.admin.CompactionConfig; import org.apache.accumulo.core.client.admin.DiskUsage; import org.apache.accumulo.core.client.admin.FindMax; import org.apache.accumulo.core.client.admin.Locations; import org.apache.accumulo.core.client.admin.NewTableConfiguration; import org.apache.accumulo.core.client.admin.SamplerConfiguration; import org.apache.accumulo.core.client.admin.TimeType; import org.apache.accumulo.core.client.impl.TableOperationsHelper; import org.apache.accumulo.core.client.impl.Tables; import org.apache.accumulo.core.conf.AccumuloConfiguration; import org.apache.accumulo.core.data.Key; import org.apache.accumulo.core.data.Mutation; import org.apache.accumulo.core.data.Range; import org.apache.accumulo.core.data.Value; import org.apache.accumulo.core.file.FileOperations; import org.apache.accumulo.core.file.FileSKVIterator; import org.apache.accumulo.core.metadata.MetadataTable; import org.apache.accumulo.core.metadata.RootTable; import org.apache.accumulo.core.security.Authorizations; import org.apache.accumulo.core.security.ColumnVisibility; import org.apache.accumulo.start.classloader.vfs.AccumuloVFSClassLoader; import org.apache.commons.lang.NotImplementedException; import org.apache.hadoop.fs.FSDataOutputStream; import org.apache.hadoop.fs.FileStatus; import org.apache.hadoop.fs.FileSystem; import org.apache.hadoop.fs.Path; import org.apache.hadoop.io.Text; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import static com.google.common.base.Preconditions.checkArgument; /** * @deprecated since 1.8.0; use MiniAccumuloCluster or a standard mock framework instead. */ @Deprecated class MockTableOperations extends TableOperationsHelper { private static final Logger log = LoggerFactory.getLogger(MockTableOperations.class); private static final byte[] ZERO = { 0 }; private final MockAccumulo acu; private final String username; MockTableOperations(MockAccumulo acu, String username) { this.acu = acu; this.username = username; } @Override public SortedSet<String> list() { return new TreeSet<String>(acu.tables.keySet()); } @Override public boolean exists(String tableName) { return acu.tables.containsKey(tableName); } private boolean namespaceExists(String namespace) { return acu.namespaces.containsKey(namespace); } @Override public void create(String tableName) throws AccumuloException, AccumuloSecurityException, TableExistsException { create(tableName, new NewTableConfiguration()); } @Override @Deprecated public void create(String tableName, boolean versioningIter) throws AccumuloException, AccumuloSecurityException, TableExistsException { create(tableName, versioningIter, TimeType.MILLIS); } @Override @Deprecated public void create(String tableName, boolean versioningIter, TimeType timeType) throws AccumuloException, AccumuloSecurityException, TableExistsException { NewTableConfiguration ntc = new NewTableConfiguration().setTimeType(timeType); if (versioningIter) create(tableName, ntc); else create(tableName, ntc.withoutDefaultIterators()); } @Override public void create(String tableName, NewTableConfiguration ntc) throws AccumuloException, AccumuloSecurityException, TableExistsException { String namespace = Tables.qualify(tableName).getFirst(); checkArgument(tableName.matches(Tables.VALID_NAME_REGEX)); if (exists(tableName)) throw new TableExistsException(tableName, tableName, ""); checkArgument(namespaceExists(namespace), "Namespace (" + namespace + ") does not exist, create it first"); acu.createTable(username, tableName, ntc.getTimeType(), ntc.getProperties()); } @Override public void addSplits(String tableName, SortedSet<Text> partitionKeys) throws TableNotFoundException, AccumuloException, AccumuloSecurityException { if (!exists(tableName)) throw new TableNotFoundException(tableName, tableName, ""); acu.addSplits(tableName, partitionKeys); } @Deprecated @Override public Collection<Text> getSplits(String tableName) throws TableNotFoundException { return listSplits(tableName); } @Deprecated @Override public Collection<Text> getSplits(String tableName, int maxSplits) throws TableNotFoundException { return listSplits(tableName); } @Override public Collection<Text> listSplits(String tableName) throws TableNotFoundException { if (!exists(tableName)) throw new TableNotFoundException(tableName, tableName, ""); return acu.getSplits(tableName); } @Override public Collection<Text> listSplits(String tableName, int maxSplits) throws TableNotFoundException { return listSplits(tableName); } @Override public void delete(String tableName) throws AccumuloException, AccumuloSecurityException, TableNotFoundException { if (!exists(tableName)) throw new TableNotFoundException(tableName, tableName, ""); acu.tables.remove(tableName); } @Override public void rename(String oldTableName, String newTableName) throws AccumuloSecurityException, TableNotFoundException, AccumuloException, TableExistsException { if (!exists(oldTableName)) throw new TableNotFoundException(oldTableName, oldTableName, ""); if (exists(newTableName)) throw new TableExistsException(newTableName, newTableName, ""); MockTable t = acu.tables.remove(oldTableName); String namespace = Tables.qualify(newTableName).getFirst(); MockNamespace n = acu.namespaces.get(namespace); if (n == null) { n = new MockNamespace(); } t.setNamespaceName(namespace); t.setNamespace(n); acu.namespaces.put(namespace, n); acu.tables.put(newTableName, t); } @Deprecated @Override public void flush(String tableName) throws AccumuloException, AccumuloSecurityException { } @Override public void setProperty(String tableName, String property, String value) throws AccumuloException, AccumuloSecurityException { acu.tables.get(tableName).settings.put(property, value); } @Override public void removeProperty(String tableName, String property) throws AccumuloException, AccumuloSecurityException { acu.tables.get(tableName).settings.remove(property); } @Override public Iterable<Entry<String, String>> getProperties(String tableName) throws TableNotFoundException { String namespace = Tables.qualify(tableName).getFirst(); if (!exists(tableName)) { if (!namespaceExists(namespace)) throw new TableNotFoundException(tableName, new NamespaceNotFoundException(null, namespace, null)); throw new TableNotFoundException(null, tableName, null); } Set<Entry<String, String>> props = new HashSet<Entry<String, String>>( acu.namespaces.get(namespace).settings.entrySet()); Set<Entry<String, String>> tableProps = acu.tables.get(tableName).settings.entrySet(); for (Entry<String, String> e : tableProps) { if (props.contains(e)) { props.remove(e); } props.add(e); } return props; } @Override public void setLocalityGroups(String tableName, Map<String, Set<Text>> groups) throws AccumuloException, AccumuloSecurityException, TableNotFoundException { if (!exists(tableName)) throw new TableNotFoundException(tableName, tableName, ""); acu.tables.get(tableName).setLocalityGroups(groups); } @Override public Map<String, Set<Text>> getLocalityGroups(String tableName) throws AccumuloException, TableNotFoundException { if (!exists(tableName)) throw new TableNotFoundException(tableName, tableName, ""); return acu.tables.get(tableName).getLocalityGroups(); } @Override public Set<Range> splitRangeByTablets(String tableName, Range range, int maxSplits) throws AccumuloException, AccumuloSecurityException, TableNotFoundException { if (!exists(tableName)) throw new TableNotFoundException(tableName, tableName, ""); return Collections.singleton(range); } @Override public void importDirectory(String tableName, String dir, String failureDir, boolean setTime) throws IOException, AccumuloException, AccumuloSecurityException, TableNotFoundException { long time = System.currentTimeMillis(); MockTable table = acu.tables.get(tableName); if (table == null) { throw new TableNotFoundException(null, tableName, "The table was not found"); } Path importPath = new Path(dir); Path failurePath = new Path(failureDir); FileSystem fs = acu.getFileSystem(); /* * check preconditions */ // directories are directories if (fs.isFile(importPath)) { throw new IOException("Import path must be a directory."); } if (fs.isFile(failurePath)) { throw new IOException("Failure path must be a directory."); } // failures are writable Path createPath = failurePath.suffix("/.createFile"); FSDataOutputStream createStream = null; try { createStream = fs.create(createPath); } catch (IOException e) { throw new IOException("Error path is not writable."); } finally { if (createStream != null) { createStream.close(); } } fs.delete(createPath, false); // failures are empty FileStatus[] failureChildStats = fs.listStatus(failurePath); if (failureChildStats.length > 0) { throw new IOException("Error path must be empty."); } /* * Begin the import - iterate the files in the path */ for (FileStatus importStatus : fs.listStatus(importPath)) { try { FileSKVIterator importIterator = FileOperations.getInstance().newReaderBuilder() .forFile(importStatus.getPath().toString(), fs, fs.getConf()) .withTableConfiguration(AccumuloConfiguration.getDefaultConfiguration()).seekToBeginning() .build(); while (importIterator.hasTop()) { Key key = importIterator.getTopKey(); Value value = importIterator.getTopValue(); if (setTime) { key.setTimestamp(time); } Mutation mutation = new Mutation(key.getRow()); if (!key.isDeleted()) { mutation.put(key.getColumnFamily(), key.getColumnQualifier(), new ColumnVisibility(key.getColumnVisibilityData().toArray()), key.getTimestamp(), value); } else { mutation.putDelete(key.getColumnFamily(), key.getColumnQualifier(), new ColumnVisibility(key.getColumnVisibilityData().toArray()), key.getTimestamp()); } table.addMutation(mutation); importIterator.next(); } } catch (Exception e) { FSDataOutputStream failureWriter = null; DataInputStream failureReader = null; try { failureWriter = fs.create(failurePath.suffix("/" + importStatus.getPath().getName())); failureReader = fs.open(importStatus.getPath()); int read = 0; byte[] buffer = new byte[1024]; while (-1 != (read = failureReader.read(buffer))) { failureWriter.write(buffer, 0, read); } } finally { if (failureReader != null) failureReader.close(); if (failureWriter != null) failureWriter.close(); } } fs.delete(importStatus.getPath(), true); } } @Override public void offline(String tableName) throws AccumuloSecurityException, AccumuloException, TableNotFoundException { offline(tableName, false); } @Override public void offline(String tableName, boolean wait) throws AccumuloSecurityException, AccumuloException, TableNotFoundException { if (!exists(tableName)) throw new TableNotFoundException(tableName, tableName, ""); } @Override public void online(String tableName) throws AccumuloSecurityException, AccumuloException, TableNotFoundException { online(tableName, false); } @Override public void online(String tableName, boolean wait) throws AccumuloSecurityException, AccumuloException, TableNotFoundException { if (!exists(tableName)) throw new TableNotFoundException(tableName, tableName, ""); } @Override public void clearLocatorCache(String tableName) throws TableNotFoundException { if (!exists(tableName)) throw new TableNotFoundException(tableName, tableName, ""); } @Override public Map<String, String> tableIdMap() { Map<String, String> result = new HashMap<String, String>(); for (Entry<String, MockTable> entry : acu.tables.entrySet()) { String table = entry.getKey(); if (RootTable.NAME.equals(table)) result.put(table, RootTable.ID); else if (MetadataTable.NAME.equals(table)) result.put(table, MetadataTable.ID); else result.put(table, entry.getValue().getTableId()); } return result; } @Override public List<DiskUsage> getDiskUsage(Set<String> tables) throws AccumuloException, AccumuloSecurityException { List<DiskUsage> diskUsages = new ArrayList<DiskUsage>(); diskUsages.add(new DiskUsage(new TreeSet<String>(tables), 0l)); return diskUsages; } @Override public void merge(String tableName, Text start, Text end) throws AccumuloException, AccumuloSecurityException, TableNotFoundException { if (!exists(tableName)) throw new TableNotFoundException(tableName, tableName, ""); acu.merge(tableName, start, end); } @Override public void deleteRows(String tableName, Text start, Text end) throws AccumuloException, AccumuloSecurityException, TableNotFoundException { if (!exists(tableName)) throw new TableNotFoundException(tableName, tableName, ""); MockTable t = acu.tables.get(tableName); Text startText = start != null ? new Text(start) : new Text(); if (startText.getLength() == 0 && end == null) { t.table.clear(); return; } Text endText = end != null ? new Text(end) : new Text(t.table.lastKey().getRow().getBytes()); startText.append(ZERO, 0, 1); endText.append(ZERO, 0, 1); Set<Key> keep = new TreeSet<Key>(t.table.subMap(new Key(startText), new Key(endText)).keySet()); t.table.keySet().removeAll(keep); } @Override public void compact(String tableName, Text start, Text end, boolean flush, boolean wait) throws AccumuloSecurityException, TableNotFoundException, AccumuloException { if (!exists(tableName)) throw new TableNotFoundException(tableName, tableName, ""); } @Override public void compact(String tableName, Text start, Text end, List<IteratorSetting> iterators, boolean flush, boolean wait) throws AccumuloSecurityException, TableNotFoundException, AccumuloException { if (!exists(tableName)) throw new TableNotFoundException(tableName, tableName, ""); if (iterators != null && iterators.size() > 0) throw new UnsupportedOperationException(); } @Override public void compact(String tableName, CompactionConfig config) throws AccumuloSecurityException, TableNotFoundException, AccumuloException { if (!exists(tableName)) throw new TableNotFoundException(tableName, tableName, ""); if (config.getIterators().size() > 0 || config.getCompactionStrategy() != null) throw new UnsupportedOperationException( "Mock does not support iterators or compaction strategies for compactions"); } @Override public void cancelCompaction(String tableName) throws AccumuloSecurityException, TableNotFoundException, AccumuloException { if (!exists(tableName)) throw new TableNotFoundException(tableName, tableName, ""); } @Override public void clone(String srcTableName, String newTableName, boolean flush, Map<String, String> propertiesToSet, Set<String> propertiesToExclude) throws AccumuloException, AccumuloSecurityException, TableNotFoundException, TableExistsException { throw new NotImplementedException(); } @Override public void flush(String tableName, Text start, Text end, boolean wait) throws AccumuloException, AccumuloSecurityException, TableNotFoundException { if (!exists(tableName)) throw new TableNotFoundException(tableName, tableName, ""); } @Override public Text getMaxRow(String tableName, Authorizations auths, Text startRow, boolean startInclusive, Text endRow, boolean endInclusive) throws TableNotFoundException, AccumuloException, AccumuloSecurityException { MockTable table = acu.tables.get(tableName); if (table == null) throw new TableNotFoundException(tableName, tableName, "no such table"); return FindMax.findMax(new MockScanner(table, auths), startRow, startInclusive, endRow, endInclusive); } @Override public void importTable(String tableName, String exportDir) throws TableExistsException, AccumuloException, AccumuloSecurityException { throw new NotImplementedException(); } @Override public void exportTable(String tableName, String exportDir) throws TableNotFoundException, AccumuloException, AccumuloSecurityException { throw new NotImplementedException(); } @Override public boolean testClassLoad(String tableName, String className, String asTypeName) throws AccumuloException, AccumuloSecurityException, TableNotFoundException { try { AccumuloVFSClassLoader.loadClass(className, Class.forName(asTypeName)); } catch (ClassNotFoundException e) { log.warn("Could not load class '" + className + "' with type name '" + asTypeName + "' in testClassLoad().", e); return false; } return true; } @Override public void setSamplerConfiguration(String tableName, SamplerConfiguration samplerConfiguration) throws TableNotFoundException, AccumuloException, AccumuloSecurityException { throw new UnsupportedOperationException(); } @Override public void clearSamplerConfiguration(String tableName) throws TableNotFoundException, AccumuloException, AccumuloSecurityException { throw new UnsupportedOperationException(); } @Override public SamplerConfiguration getSamplerConfiguration(String tableName) throws TableNotFoundException, AccumuloException, AccumuloSecurityException { throw new UnsupportedOperationException(); } @Override public Locations locate(String tableName, Collection<Range> ranges) throws AccumuloException, AccumuloSecurityException, TableNotFoundException { throw new UnsupportedOperationException(); } }