Uses of Class org.apache.hadoop.conf.Configuration (Hadoop 1.2.1 API)

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV NEXT

FRAMES NO FRAMES

Uses of Class
org.apache.hadoop.conf.Configuration

Packages that use Configuration
org.apache.hadoop.conf	Configuration of system parameters.
org.apache.hadoop.contrib.failmon
org.apache.hadoop.contrib.index.example
org.apache.hadoop.contrib.index.lucene
org.apache.hadoop.contrib.index.mapred
org.apache.hadoop.examples	Hadoop example code.
org.apache.hadoop.filecache
org.apache.hadoop.fs	An abstract file system API.
org.apache.hadoop.fs.ftp
org.apache.hadoop.fs.kfs	A client for the Kosmos filesystem (KFS)
org.apache.hadoop.fs.permission
org.apache.hadoop.fs.s3	A distributed, block-based implementation of `FileSystem` that uses Amazon S3 as a backing store.
org.apache.hadoop.fs.s3native	A distributed implementation of `FileSystem` for reading and writing files on Amazon S3.
org.apache.hadoop.fs.shell
org.apache.hadoop.http
org.apache.hadoop.http.lib
org.apache.hadoop.io	Generic i/o code for use when reading and writing data to the network, to databases, and to files.
org.apache.hadoop.io.compress
org.apache.hadoop.io.compress.bzip2
org.apache.hadoop.io.compress.snappy
org.apache.hadoop.io.compress.zlib
org.apache.hadoop.io.file.tfile
org.apache.hadoop.io.retry	A mechanism for selectively retrying methods that throw exceptions under certain circumstances.
org.apache.hadoop.io.serializer	This package provides a mechanism for using different serialization frameworks in Hadoop.
org.apache.hadoop.ipc	Tools to help define network clients and servers.
org.apache.hadoop.mapred	A software framework for easily writing applications which process vast amounts of data (multi-terabyte data-sets) parallelly on large clusters (thousands of nodes) built of commodity hardware in a reliable, fault-tolerant manner.
org.apache.hadoop.mapred.join	Given a set of sorted datasets keyed with the same class and yielding equal partitions, it is possible to effect a join of those datasets prior to the map.
org.apache.hadoop.mapred.lib	Library of generally useful mappers, reducers, and partitioners.
org.apache.hadoop.mapred.pipes	Hadoop Pipes allows C++ code to use Hadoop DFS and map/reduce.
org.apache.hadoop.mapred.tools
org.apache.hadoop.mapreduce
org.apache.hadoop.mapreduce.lib.db
org.apache.hadoop.mapreduce.lib.input
org.apache.hadoop.mapreduce.lib.jobcontrol
org.apache.hadoop.mapreduce.lib.partition
org.apache.hadoop.mapreduce.security
org.apache.hadoop.mapreduce.security.token
org.apache.hadoop.mapreduce.server.tasktracker.userlogs
org.apache.hadoop.mapreduce.split
org.apache.hadoop.net	Network-related classes.
org.apache.hadoop.security
org.apache.hadoop.security.authorize
org.apache.hadoop.security.token
org.apache.hadoop.streaming	`Hadoop Streaming` is a utility which allows users to create and run Map-Reduce jobs with any executables (e.g.
org.apache.hadoop.typedbytes	Typed bytes are sequences of bytes in which the first byte is a type code.
org.apache.hadoop.util	Common utilities.
org.apache.hadoop.util.hash

Uses of Configuration in org.apache.hadoop.conf

Methods in org.apache.hadoop.conf that return Configuration
`Configuration`	`Configurable.getConf()` Return the configuration used by this object.
`Configuration`	`Configured.getConf()`

Methods in org.apache.hadoop.conf with parameters of type Configuration
`static void`	`Configuration.dumpConfiguration(Configuration config, Writer out)` Writes out all the parameters and their properties (final and resource) to the given `Writer` The format of the output would be { "properties" : [ {key1,value1,key1.isFinal,key1.resource}, {key2,value2, key2.isFinal,key2.resource}...
`void`	`Configurable.setConf(Configuration conf)` Set the configuration to be used by this object.
`void`	`Configured.setConf(Configuration conf)`

Constructors in org.apache.hadoop.conf with parameters of type Configuration
`Configuration(Configuration other)` A new configuration with the same settings cloned from another.
`Configured(Configuration conf)` Construct a Configured.

Uses of Configuration in org.apache.hadoop.contrib.failmon

Constructors in org.apache.hadoop.contrib.failmon with parameters of type Configuration
`Executor(Configuration conf)` Create an instance of the class and read the configuration file to determine the set of jobs that will be run and the maximum interval for which the thread can sleep before it wakes up to execute a monitoring job on the node.

Uses of Configuration in org.apache.hadoop.contrib.index.example

Constructors in org.apache.hadoop.contrib.index.example with parameters of type Configuration
`LineDocRecordReader(Configuration job, FileSplit split)` Constructor

Uses of Configuration in org.apache.hadoop.contrib.index.lucene

Constructors in org.apache.hadoop.contrib.index.lucene with parameters of type Configuration
`FileSystemDirectory(FileSystem fs, Path directory, boolean create, Configuration conf)` Constructor

Uses of Configuration in org.apache.hadoop.contrib.index.mapred

Methods in org.apache.hadoop.contrib.index.mapred that return Configuration
`Configuration`	`IndexUpdateConfiguration.getConfiguration()` Get the underlying configuration object.

Methods in org.apache.hadoop.contrib.index.mapred with parameters of type Configuration
`void`	`IndexUpdater.run(Configuration conf, Path[] inputPaths, Path outputPath, int numMapTasks, Shard[] shards)`
`void`	`IIndexUpdater.run(Configuration conf, Path[] inputPaths, Path outputPath, int numMapTasks, Shard[] shards)` Create a Map/Reduce job configuration and run the Map/Reduce job to analyze documents and update Lucene instances in parallel.

Constructors in org.apache.hadoop.contrib.index.mapred with parameters of type Configuration
`IndexUpdateConfiguration(Configuration conf)` Constructor

Uses of Configuration in org.apache.hadoop.examples

Constructors in org.apache.hadoop.examples with parameters of type Configuration
`MultiFileWordCount.MultiFileLineRecordReader(Configuration conf, MultiFileSplit split)`

Uses of Configuration in org.apache.hadoop.filecache

Methods in org.apache.hadoop.filecache with parameters of type Configuration
`static void`	`DistributedCache.addArchiveToClassPath(Path archive, Configuration conf)` Deprecated. Please use `DistributedCache.addArchiveToClassPath(Path, Configuration, FileSystem)` instead. The `FileSystem` should be obtained within an appropriate `doAs`.
`static void`	`DistributedCache.addArchiveToClassPath(Path archive, Configuration conf, FileSystem fs)` Add an archive path to the current set of classpath entries.
`static void`	`DistributedCache.addCacheArchive(URI uri, Configuration conf)` Add a archives to be localized to the conf.
`static void`	`DistributedCache.addCacheFile(URI uri, Configuration conf)` Add a file to be localized to the conf.
`static void`	`DistributedCache.addFileToClassPath(Path file, Configuration conf)` Deprecated. Please use `DistributedCache.addFileToClassPath(Path, Configuration, FileSystem)` instead. The `FileSystem` should be obtained within an appropriate `doAs`.
`static void`	`DistributedCache.addFileToClassPath(Path file, Configuration conf, FileSystem fs)` Add a file path to the current set of classpath entries.
`static void`	`DistributedCache.addLocalArchives(Configuration conf, String str)` Add a archive that has been localized to the conf.
`static void`	`DistributedCache.addLocalFiles(Configuration conf, String str)` Add a file that has been localized to the conf..
`static void`	`TrackerDistributedCacheManager.createAllSymlink(Configuration conf, File jobCacheDir, File workDir)` This method create symlinks for all files in a given dir in another directory.
`static void`	`DistributedCache.createAllSymlink(Configuration conf, File jobCacheDir, File workDir)` Deprecated. Internal to MapReduce framework. Use DistributedCacheManager instead.
`static void`	`DistributedCache.createSymlink(Configuration conf)` This method allows you to create symlinks in the current working directory of the task to all the cache files/archives.
`static void`	`TrackerDistributedCacheManager.determineTimestampsAndCacheVisibilities(Configuration job)` Determines timestamps of files to be cached, and stores those in the configuration.
`static long`	`TrackerDistributedCacheManager.downloadCacheObject(Configuration conf, URI source, Path destination, long desiredTimestamp, boolean isArchive, FsPermission permission)` Download a given path to the local file system.
`static Path[]`	`DistributedCache.getArchiveClassPaths(Configuration conf)` Get the archive entries in classpath as an array of Path.
`static long[]`	`DistributedCache.getArchiveTimestamps(Configuration conf)` Get the timestamps of the archives.
`static boolean[]`	`TrackerDistributedCacheManager.getArchiveVisibilities(Configuration conf)` Get the booleans on whether the archives are public or not.
`static URI[]`	`DistributedCache.getCacheArchives(Configuration conf)` Get cache archives set in the Configuration.
`static URI[]`	`DistributedCache.getCacheFiles(Configuration conf)` Get cache files set in the Configuration.
`static void`	`TrackerDistributedCacheManager.getDelegationTokens(Configuration job, Credentials credentials)` For each archive or cache file - get the corresponding delegation token
`static Path[]`	`DistributedCache.getFileClassPaths(Configuration conf)` Get the file entries in classpath as an array of Path.
`static FileStatus`	`DistributedCache.getFileStatus(Configuration conf, URI cache)` Returns `FileStatus` of a given cache file on hdfs.
`static long[]`	`DistributedCache.getFileTimestamps(Configuration conf)` Get the timestamps of the files.
`static boolean[]`	`TrackerDistributedCacheManager.getFileVisibilities(Configuration conf)` Get the booleans on whether the files are public or not.
`static Path[]`	`DistributedCache.getLocalCacheArchives(Configuration conf)` Return the path array of the localized caches.
`static Path[]`	`DistributedCache.getLocalCacheFiles(Configuration conf)` Return the path array of the localized files.
`static boolean`	`DistributedCache.getSymlink(Configuration conf)` This method checks to see if symlinks are to be create for the localized cache files in the current working directory Used by internal DistributedCache code.
`static long`	`DistributedCache.getTimestamp(Configuration conf, URI cache)` Returns mtime of a given cache file on hdfs.
`TaskDistributedCacheManager`	`TrackerDistributedCacheManager.newTaskDistributedCacheManager(JobID jobId, Configuration taskConf)`
`static void`	`DistributedCache.setArchiveTimestamps(Configuration conf, String timestamps)` This is to check the timestamp of the archives to be localized.
`static void`	`DistributedCache.setCacheArchives(URI[] archives, Configuration conf)` Set the configuration with the given set of archives.
`static void`	`DistributedCache.setCacheFiles(URI[] files, Configuration conf)` Set the configuration with the given set of files.
`static void`	`DistributedCache.setFileTimestamps(Configuration conf, String timestamps)` This is to check the timestamp of the files to be localized.
`static void`	`DistributedCache.setLocalArchives(Configuration conf, String str)` Set the conf to contain the location for localized archives.
`static void`	`DistributedCache.setLocalFiles(Configuration conf, String str)` Set the conf to contain the location for localized files.
`void`	`TaskDistributedCacheManager.setupCache(Configuration taskConf, String publicCacheSubdir, String privateCacheSubdir)` Retrieve public distributed cache files into the local cache and updates the task configuration (which has been passed in via the constructor).
`static void`	`TrackerDistributedCacheManager.validate(Configuration conf)` This is part of the framework API.

Constructors in org.apache.hadoop.filecache with parameters of type Configuration
`TrackerDistributedCacheManager.CleanupThread(Configuration conf)`
`TrackerDistributedCacheManager(Configuration conf, TaskController controller)`

Uses of Configuration in org.apache.hadoop.fs

Methods in org.apache.hadoop.fs that return Configuration
`Configuration`	`FilterFileSystem.getConf()`

Methods in org.apache.hadoop.fs with parameters of type Configuration
`static void`	`FileSystem.addFileSystemForTesting(URI uri, Configuration conf, FileSystem fs)` This method adds a file system for testing so that we can find it later.
`static boolean`	`FileUtil.copy(File src, FileSystem dstFS, Path dst, boolean deleteSource, Configuration conf)` Copy local files to a FileSystem.
`static boolean`	`FileUtil.copy(FileSystem srcFS, Path[] srcs, FileSystem dstFS, Path dst, boolean deleteSource, boolean overwrite, Configuration conf)`
`static boolean`	`FileUtil.copy(FileSystem srcFS, Path src, File dst, boolean deleteSource, Configuration conf)` Copy FileSystem files to local files.
`static boolean`	`FileUtil.copy(FileSystem srcFS, Path src, FileSystem dstFS, Path dst, boolean deleteSource, boolean overwrite, Configuration conf)` Copy files between FileSystems.
`static boolean`	`FileUtil.copy(FileSystem srcFS, Path src, FileSystem dstFS, Path dst, boolean deleteSource, Configuration conf)` Copy files between FileSystems.
`static boolean`	`FileUtil.copyMerge(FileSystem srcFS, Path srcDir, FileSystem dstFS, Path dstFile, boolean deleteSource, Configuration conf, String addString)` Copy all files in a directory to one output file (merge).
`File`	`LocalDirAllocator.createTmpFileForWrite(String pathStr, long size, Configuration conf)` Creates a temporary file in the local FS.
`static FileSystem`	`FileSystem.get(Configuration conf)` Returns the configured filesystem implementation.
`static FileSystem`	`FileSystem.get(URI uri, Configuration conf)` Returns the FileSystem for this URI's scheme and authority.
`static FileSystem`	`FileSystem.get(URI uri, Configuration conf, String user)`
`Iterable<Path>`	`LocalDirAllocator.getAllLocalPathsToRead(String pathStr, Configuration conf)` Get all of the paths that currently exist in the working directories.
`static URI`	`FileSystem.getDefaultUri(Configuration conf)` Get the default filesystem URI from a configuration.
`FileSystem`	`Path.getFileSystem(Configuration conf)` Return the FileSystem that owns this Path.
`static LocalFileSystem`	`FileSystem.getLocal(Configuration conf)` Get the local file syste
`Path`	`LocalDirAllocator.getLocalPathForWrite(String pathStr, Configuration conf)` Get a path from the local FS.
`Path`	`LocalDirAllocator.getLocalPathForWrite(String pathStr, long size, Configuration conf)` Get a path from the local FS.
`Path`	`LocalDirAllocator.getLocalPathForWrite(String pathStr, long size, Configuration conf, boolean checkWrite)` Get a path from the local FS.
`Path`	`LocalDirAllocator.getLocalPathToRead(String pathStr, Configuration conf)` Get a path from the local FS for reading.
`static FileSystem`	`FileSystem.getNamed(String name, Configuration conf)` Deprecated. call #get(URI,Configuration) instead.
`boolean`	`LocalDirAllocator.ifExists(String pathStr, Configuration conf)` We search through all the configured dirs for the file's existence and return true when we find
`void`	`FilterFileSystem.initialize(URI name, Configuration conf)` Called after a new FileSystem instance is constructed.
`void`	`HarFileSystem.initialize(URI name, Configuration conf)` Initialize a Har filesystem per har archive.
`void`	`RawLocalFileSystem.initialize(URI uri, Configuration conf)`
`void`	`FileSystem.initialize(URI name, Configuration conf)` Called after a new FileSystem instance is constructed.
`void`	`ChecksumFileSystem.setConf(Configuration conf)`
`static void`	`FileSystem.setDefaultUri(Configuration conf, String uri)` Set the default filesystem URI in a configuration.
`static void`	`FileSystem.setDefaultUri(Configuration conf, URI uri)` Set the default filesystem URI in a configuration.

Constructors in org.apache.hadoop.fs with parameters of type Configuration
`DF(File path, Configuration conf)`
`DU(File path, Configuration conf)` Keeps track of disk usage.
`FsShell(Configuration conf)`
`FsUrlStreamHandlerFactory(Configuration conf)`
`InMemoryFileSystem(URI uri, Configuration conf)` Deprecated.
`Trash(Configuration conf)` Construct a trash can accessor.
`Trash(FileSystem fs, Configuration conf)` Construct a trash can accessor for the FileSystem provided.

Uses of Configuration in org.apache.hadoop.fs.ftp

Methods in org.apache.hadoop.fs.ftp with parameters of type Configuration
`void`	`FTPFileSystem.initialize(URI uri, Configuration conf)`

Uses of Configuration in org.apache.hadoop.fs.kfs

Methods in org.apache.hadoop.fs.kfs with parameters of type Configuration
`void`	`KosmosFileSystem.initialize(URI uri, Configuration conf)`

Uses of Configuration in org.apache.hadoop.fs.permission

Methods in org.apache.hadoop.fs.permission with parameters of type Configuration
`static FsPermission`	`FsPermission.getUMask(Configuration conf)` Get the user file creation mask (umask) `UMASK_LABEL` config param has umask value that is either symbolic or octal.
`static void`	`FsPermission.setUMask(Configuration conf, FsPermission umask)` Set the user file creation mask (umask)

Uses of Configuration in org.apache.hadoop.fs.s3

Methods in org.apache.hadoop.fs.s3 with parameters of type Configuration
`void`	`FileSystemStore.initialize(URI uri, Configuration conf)`
`void`	`S3Credentials.initialize(URI uri, Configuration conf)`
`void`	`S3FileSystem.initialize(URI uri, Configuration conf)`

Uses of Configuration in org.apache.hadoop.fs.s3native

Methods in org.apache.hadoop.fs.s3native with parameters of type Configuration
`void`	`NativeS3FileSystem.initialize(URI uri, Configuration conf)`

Uses of Configuration in org.apache.hadoop.fs.shell

Constructors in org.apache.hadoop.fs.shell with parameters of type Configuration
`Command(Configuration conf)` Constructor
`Count(String[] cmd, int pos, Configuration conf)` Constructor

Uses of Configuration in org.apache.hadoop.http

Methods in org.apache.hadoop.http with parameters of type Configuration
`void`	`HttpServer.addSslListener(InetSocketAddress addr, Configuration sslConf, boolean needClientAuth)` Configure an ssl listener on the server.
`void`	`HttpServer.addSslListener(InetSocketAddress addr, Configuration sslConf, boolean needCertsAuth, boolean needKrbAuth)` Configure an ssl listener on the server.
`org.mortbay.jetty.Connector`	`HttpServer.createBaseListener(Configuration conf)` Create a required listener for the Jetty instance listening on the port provided.
`abstract void`	`FilterInitializer.initFilter(FilterContainer container, Configuration conf)` Initialize a Filter to a FilterContainer.

Constructors in org.apache.hadoop.http with parameters of type Configuration
`HttpServer(String name, String bindAddress, int port, boolean findPort, Configuration conf)`
`HttpServer(String name, String bindAddress, int port, boolean findPort, Configuration conf, AccessControlList adminsAcl)` Create a status server on the given port.
`HttpServer(String name, String bindAddress, int port, boolean findPort, Configuration conf, AccessControlList adminsAcl, org.mortbay.jetty.Connector connector)`
`HttpServer(String name, String bindAddress, int port, boolean findPort, Configuration conf, org.mortbay.jetty.Connector connector)`

Uses of Configuration in org.apache.hadoop.http.lib

Methods in org.apache.hadoop.http.lib with parameters of type Configuration
`void`	`StaticUserWebFilter.initFilter(FilterContainer container, Configuration conf)`

Uses of Configuration in org.apache.hadoop.io

Methods in org.apache.hadoop.io that return Configuration
`Configuration`	`AbstractMapWritable.getConf()`
`Configuration`	`GenericWritable.getConf()`
`Configuration`	`ObjectWritable.getConf()`

Methods in org.apache.hadoop.io with parameters of type Configuration

static



<T extends Writable> 


T

WritableUtils.clone(T orig,
      Configuration conf)

Make a copy of a writable object using serialization to a buffer.

static void IOUtils.copyBytes(InputStream in, OutputStream out, Configuration conf)
Copies from one stream to another.

static void IOUtils.copyBytes(InputStream in, OutputStream out, Configuration conf, boolean close)
Copies from one stream to another.

protected SequenceFile.Reader MapFile.Reader.createDataFileReader(FileSystem fs, Path dataFile, Configuration conf)
Override this method to specialize the type of SequenceFile.Reader returned.

static SequenceFile.Writer SequenceFile.createWriter(Configuration conf, FSDataOutputStream out, Class keyClass, Class valClass, SequenceFile.CompressionType compressionType, CompressionCodec codec)
Construct the preferred type of 'raw' SequenceFile Writer.

static SequenceFile.Writer SequenceFile.createWriter(Configuration conf, FSDataOutputStream out, Class keyClass, Class valClass, SequenceFile.CompressionType compressionType, CompressionCodec codec, SequenceFile.Metadata metadata)
Construct the preferred type of 'raw' SequenceFile Writer.

static SequenceFile.Writer SequenceFile.createWriter(FileSystem fs, Configuration conf, Path name, Class keyClass, Class valClass)
Construct the preferred type of SequenceFile Writer.

static SequenceFile.Writer SequenceFile.createWriter(FileSystem fs, Configuration conf, Path name, Class keyClass, Class valClass, int bufferSize, short replication, long blockSize, boolean createParent, SequenceFile.CompressionType compressionType, CompressionCodec codec, SequenceFile.Metadata metadata)
Construct the preferred type of SequenceFile Writer.

static SequenceFile.Writer SequenceFile.createWriter(FileSystem fs, Configuration conf, Path name, Class keyClass, Class valClass, int bufferSize, short replication, long blockSize, SequenceFile.CompressionType compressionType, CompressionCodec codec, Progressable progress, SequenceFile.Metadata metadata)
Construct the preferred type of SequenceFile Writer.

static SequenceFile.Writer SequenceFile.createWriter(FileSystem fs, Configuration conf, Path name, Class keyClass, Class valClass, SequenceFile.CompressionType compressionType)
Construct the preferred type of SequenceFile Writer.

static SequenceFile.Writer SequenceFile.createWriter(FileSystem fs, Configuration conf, Path name, Class keyClass, Class valClass, SequenceFile.CompressionType compressionType, CompressionCodec codec)
Construct the preferred type of SequenceFile Writer.

static SequenceFile.Writer SequenceFile.createWriter(FileSystem fs, Configuration conf, Path name, Class keyClass, Class valClass, SequenceFile.CompressionType compressionType, CompressionCodec codec, Progressable progress)
Construct the preferred type of SequenceFile Writer.

static SequenceFile.Writer SequenceFile.createWriter(FileSystem fs, Configuration conf, Path name, Class keyClass, Class valClass, SequenceFile.CompressionType compressionType, CompressionCodec codec, Progressable progress, SequenceFile.Metadata metadata)
Construct the preferred type of SequenceFile Writer.

static SequenceFile.Writer SequenceFile.createWriter(FileSystem fs, Configuration conf, Path name, Class keyClass, Class valClass, SequenceFile.CompressionType compressionType, Progressable progress)
Construct the preferred type of SequenceFile Writer.

static long MapFile.fix(FileSystem fs, Path dir, Class<? extends Writable> keyClass, Class<? extends Writable> valueClass, boolean dryrun, Configuration conf)
This method attempts to fix a corrupt MapFile by re-creating its index.

static Class<?> WritableName.getClass(String name, Configuration conf)
Return the class for a name.

static SequenceFile.CompressionType SequenceFile.getCompressionType(Configuration job)
Deprecated. Use SequenceFileOutputFormat.getOutputCompressionType(org.apache.hadoop.mapred.JobConf) to get SequenceFile.CompressionType for job-outputs.

static



<K> K

DefaultStringifier.load(Configuration conf,
     String keyName,
     Class<K> itemClass)

Restores the object from the configuration.

static



<K> K[]

DefaultStringifier.loadArray(Configuration conf,
          String keyName,
          Class<K> itemClass)

Restores the array of objects from the configuration.

static Writable WritableFactories.newInstance(Class<? extends Writable> c, Configuration conf)
Create a new instance of a class with a defined factory.

protected void MapFile.Reader.open(FileSystem fs, String dirName, WritableComparator comparator, Configuration conf)

static Object ObjectWritable.readObject(DataInput in, Configuration conf)
Read a Writable, String, primitive type, or an array of the preceding.

static Object ObjectWritable.readObject(DataInput in, ObjectWritable objectWritable, Configuration conf)
Read a Writable, String, primitive type, or an array of the preceding.

static void SequenceFile.setCompressionType(Configuration job, SequenceFile.CompressionType val)
Deprecated. Use the one of the many SequenceFile.createWriter methods to specify the SequenceFile.CompressionType while creating the SequenceFile or SequenceFileOutputFormat.setOutputCompressionType(org.apache.hadoop.mapred.JobConf, org.apache.hadoop.io.SequenceFile.CompressionType) to specify the SequenceFile.CompressionType for job-outputs. or

void AbstractMapWritable.setConf(Configuration conf)

void GenericWritable.setConf(Configuration conf)

void ObjectWritable.setConf(Configuration conf)

static void MapFile.Writer.setIndexInterval(Configuration conf, int interval)
Sets the index interval and stores it in conf

static



<K> void

DefaultStringifier.store(Configuration conf,
      K item,
      String keyName)

Stores the item in the configuration with the given keyName.

static



<K> void

DefaultStringifier.storeArray(Configuration conf,
           K[] items,
           String keyName)

Stores the array of items in the configuration with the given keyName.

static void ObjectWritable.writeObject(DataOutput out, Object instance, Class declaredClass, Configuration conf)
Write a Writable, String, primitive type, or an array of the preceding.

Constructors in org.apache.hadoop.io with parameters of type Configuration
`ArrayFile.Reader(FileSystem fs, String file, Configuration conf)` Construct an array reader for the named file.
`ArrayFile.Writer(Configuration conf, FileSystem fs, String file, Class<? extends Writable> valClass)` Create the named file for values of the named class.
`ArrayFile.Writer(Configuration conf, FileSystem fs, String file, Class<? extends Writable> valClass, SequenceFile.CompressionType compress, Progressable progress)` Create the named file for values of the named class.
`BloomMapFile.Reader(FileSystem fs, String dirName, Configuration conf)`
`BloomMapFile.Reader(FileSystem fs, String dirName, WritableComparator comparator, Configuration conf)`
`BloomMapFile.Reader(FileSystem fs, String dirName, WritableComparator comparator, Configuration conf, boolean open)`
`BloomMapFile.Writer(Configuration conf, FileSystem fs, String dirName, Class<? extends WritableComparable> keyClass, Class valClass)`
`BloomMapFile.Writer(Configuration conf, FileSystem fs, String dirName, Class<? extends WritableComparable> keyClass, Class<? extends Writable> valClass, SequenceFile.CompressionType compress, CompressionCodec codec, Progressable progress)`
`BloomMapFile.Writer(Configuration conf, FileSystem fs, String dirName, Class<? extends WritableComparable> keyClass, Class valClass, SequenceFile.CompressionType compress)`
`BloomMapFile.Writer(Configuration conf, FileSystem fs, String dirName, Class<? extends WritableComparable> keyClass, Class valClass, SequenceFile.CompressionType compress, Progressable progress)`
`BloomMapFile.Writer(Configuration conf, FileSystem fs, String dirName, WritableComparator comparator, Class valClass)`
`BloomMapFile.Writer(Configuration conf, FileSystem fs, String dirName, WritableComparator comparator, Class valClass, SequenceFile.CompressionType compress)`
`BloomMapFile.Writer(Configuration conf, FileSystem fs, String dirName, WritableComparator comparator, Class valClass, SequenceFile.CompressionType compress, CompressionCodec codec, Progressable progress)`
`BloomMapFile.Writer(Configuration conf, FileSystem fs, String dirName, WritableComparator comparator, Class valClass, SequenceFile.CompressionType compress, Progressable progress)`
`DefaultStringifier(Configuration conf, Class<T> c)`
`MapFile.Reader(FileSystem fs, String dirName, Configuration conf)` Construct a map reader for the named map.
`MapFile.Reader(FileSystem fs, String dirName, WritableComparator comparator, Configuration conf)` Construct a map reader for the named map using the named comparator.
`MapFile.Reader(FileSystem fs, String dirName, WritableComparator comparator, Configuration conf, boolean open)` Hook to allow subclasses to defer opening streams until further initialization is complete.
`MapFile.Writer(Configuration conf, FileSystem fs, String dirName, Class<? extends WritableComparable> keyClass, Class valClass)` Create the named map for keys of the named class.
`MapFile.Writer(Configuration conf, FileSystem fs, String dirName, Class<? extends WritableComparable> keyClass, Class valClass, SequenceFile.CompressionType compress)` Create the named map for keys of the named class.
`MapFile.Writer(Configuration conf, FileSystem fs, String dirName, Class<? extends WritableComparable> keyClass, Class valClass, SequenceFile.CompressionType compress, CompressionCodec codec, Progressable progress)` Create the named map for keys of the named class.
`MapFile.Writer(Configuration conf, FileSystem fs, String dirName, Class<? extends WritableComparable> keyClass, Class valClass, SequenceFile.CompressionType compress, Progressable progress)` Create the named map for keys of the named class.
`MapFile.Writer(Configuration conf, FileSystem fs, String dirName, WritableComparator comparator, Class valClass)` Create the named map using the named key comparator.
`MapFile.Writer(Configuration conf, FileSystem fs, String dirName, WritableComparator comparator, Class valClass, SequenceFile.CompressionType compress)` Create the named map using the named key comparator.
`MapFile.Writer(Configuration conf, FileSystem fs, String dirName, WritableComparator comparator, Class valClass, SequenceFile.CompressionType compress, CompressionCodec codec, Progressable progress)` Create the named map using the named key comparator.
`MapFile.Writer(Configuration conf, FileSystem fs, String dirName, WritableComparator comparator, Class valClass, SequenceFile.CompressionType compress, Progressable progress)` Create the named map using the named key comparator.
`SequenceFile.Reader(FileSystem fs, Path file, Configuration conf)` Open the named file.
`SequenceFile.Sorter(FileSystem fs, Class<? extends WritableComparable> keyClass, Class valClass, Configuration conf)` Sort and merge files containing the named classes.
`SequenceFile.Sorter(FileSystem fs, RawComparator comparator, Class keyClass, Class valClass, Configuration conf)` Sort and merge using an arbitrary `RawComparator`.
`SequenceFile.Writer(FileSystem fs, Configuration conf, Path name, Class keyClass, Class valClass)` Create the named file.
`SequenceFile.Writer(FileSystem fs, Configuration conf, Path name, Class keyClass, Class valClass, int bufferSize, short replication, long blockSize, Progressable progress, SequenceFile.Metadata metadata)` Create the named file with write-progress reporter.
`SequenceFile.Writer(FileSystem fs, Configuration conf, Path name, Class keyClass, Class valClass, Progressable progress, SequenceFile.Metadata metadata)` Create the named file with write-progress reporter.
`SetFile.Reader(FileSystem fs, String dirName, Configuration conf)` Construct a set reader for the named set.
`SetFile.Reader(FileSystem fs, String dirName, WritableComparator comparator, Configuration conf)` Construct a set reader for the named set using the named comparator.
`SetFile.Writer(Configuration conf, FileSystem fs, String dirName, Class<? extends WritableComparable> keyClass, SequenceFile.CompressionType compress)` Create a set naming the element class and compression type.
`SetFile.Writer(Configuration conf, FileSystem fs, String dirName, WritableComparator comparator, SequenceFile.CompressionType compress)` Create a set naming the element comparator and compression type.

Uses of Configuration in org.apache.hadoop.io.compress

Methods in org.apache.hadoop.io.compress that return Configuration
`Configuration`	`SnappyCodec.getConf()` Return the configuration used by this object.
`Configuration`	`DefaultCodec.getConf()`

Methods in org.apache.hadoop.io.compress with parameters of type Configuration
`static List<Class<? extends CompressionCodec>>`	`CompressionCodecFactory.getCodecClasses(Configuration conf)` Get the list of codecs listed in the configuration
`static Compressor`	`CodecPool.getCompressor(CompressionCodec codec, Configuration conf)` Get a `Compressor` for the given `CompressionCodec` from the pool or a new one.
`static boolean`	`SnappyCodec.isNativeSnappyLoaded(Configuration conf)` Are the native snappy libraries loaded & initialized?
`void`	`Compressor.reinit(Configuration conf)` Prepare the compressor to be used in a new stream with settings defined in the given Configuration
`static void`	`CompressionCodecFactory.setCodecClasses(Configuration conf, List<Class> classes)` Sets a list of codec classes in the configuration.
`void`	`SnappyCodec.setConf(Configuration conf)` Set the configuration to be used by this object.
`void`	`DefaultCodec.setConf(Configuration conf)`

Constructors in org.apache.hadoop.io.compress with parameters of type Configuration
`CompressionCodecFactory(Configuration conf)` Find the codecs specified in the config value io.compression.codecs and register them.

Uses of Configuration in org.apache.hadoop.io.compress.bzip2

Methods in org.apache.hadoop.io.compress.bzip2 with parameters of type Configuration
`void`	`BZip2DummyCompressor.reinit(Configuration conf)`

Uses of Configuration in org.apache.hadoop.io.compress.snappy

Methods in org.apache.hadoop.io.compress.snappy with parameters of type Configuration
`void`	`SnappyCompressor.reinit(Configuration conf)` Prepare the compressor to be used in a new stream with settings defined in the given Configuration

Uses of Configuration in org.apache.hadoop.io.compress.zlib

Methods in org.apache.hadoop.io.compress.zlib with parameters of type Configuration
`static ZlibCompressor.CompressionLevel`	`ZlibFactory.getCompressionLevel(Configuration conf)`
`static ZlibCompressor.CompressionStrategy`	`ZlibFactory.getCompressionStrategy(Configuration conf)`
`static Compressor`	`ZlibFactory.getZlibCompressor(Configuration conf)` Return the appropriate implementation of the zlib compressor.
`static Class<? extends Compressor>`	`ZlibFactory.getZlibCompressorType(Configuration conf)` Return the appropriate type of the zlib compressor.
`static Decompressor`	`ZlibFactory.getZlibDecompressor(Configuration conf)` Return the appropriate implementation of the zlib decompressor.
`static Class<? extends Decompressor>`	`ZlibFactory.getZlibDecompressorType(Configuration conf)` Return the appropriate type of the zlib decompressor.
`static boolean`	`ZlibFactory.isNativeZlibLoaded(Configuration conf)` Check if native-zlib code is loaded & initialized correctly and can be loaded for this job.
`void`	`BuiltInZlibDeflater.reinit(Configuration conf)` reinit the compressor with the given configuration.
`void`	`ZlibCompressor.reinit(Configuration conf)` Prepare the compressor to be used in a new stream with settings defined in the given Configuration.
`static void`	`ZlibFactory.setCompressionLevel(Configuration conf, ZlibCompressor.CompressionLevel level)`
`static void`	`ZlibFactory.setCompressionStrategy(Configuration conf, ZlibCompressor.CompressionStrategy strategy)`

Constructors in org.apache.hadoop.io.compress.zlib with parameters of type Configuration
`ZlibCompressor(Configuration conf)` Creates a new compressor, taking settings from the configuration.

Uses of Configuration in org.apache.hadoop.io.file.tfile

Constructors in org.apache.hadoop.io.file.tfile with parameters of type Configuration
`TFile.Reader(FSDataInputStream fsdis, long fileLength, Configuration conf)` Constructor
`TFile.Writer(FSDataOutputStream fsdos, int minBlockSize, String compressName, String comparator, Configuration conf)` Constructor

Uses of Configuration in org.apache.hadoop.io.retry

Methods in org.apache.hadoop.io.retry with parameters of type Configuration
`static RetryPolicy`	`RetryUtils.getDefaultRetryPolicy(Configuration conf, String retryPolicyEnabledKey, boolean defaultRetryPolicyEnabled, String retryPolicySpecKey, String defaultRetryPolicySpec, Class<? extends Exception>... remoteExceptionsToRetry)` Return the default retry policy set in conf.
`static RetryPolicy`	`RetryUtils.getMultipleLinearRandomRetry(Configuration conf, String retryPolicyEnabledKey, boolean defaultRetryPolicyEnabled, String retryPolicySpecKey, String defaultRetryPolicySpec)` Return the MultipleLinearRandomRetry policy specified in the conf, or null if the feature is disabled.

Uses of Configuration in org.apache.hadoop.io.serializer

Constructors in org.apache.hadoop.io.serializer with parameters of type Configuration
`SerializationFactory(Configuration conf)` Serializations are found by reading the `io.serializations` property from `conf`, which is a comma-delimited list of classnames.

Uses of Configuration in org.apache.hadoop.ipc

Methods in org.apache.hadoop.ipc with parameters of type Configuration
`static Object[]`	`RPC.call(Method method, Object[][] params, InetSocketAddress[] addrs, Configuration conf)` Deprecated. Use `RPC.call(Method, Object[][], InetSocketAddress[], UserGroupInformation, Configuration)` instead
`static Object[]`	`RPC.call(Method method, Object[][] params, InetSocketAddress[] addrs, UserGroupInformation ticket, Configuration conf)` Expert: Make multiple, parallel calls to a set of servers.
`Writable[]`	`Client.call(Writable[] params, InetSocketAddress[] addresses, Class<?> protocol, UserGroupInformation ticket, Configuration conf)` Makes a set of calls in parallel.
`Writable`	`Client.call(Writable param, InetSocketAddress addr, Class<?> protocol, UserGroupInformation ticket, int rpcTimeout, Configuration conf)` Make a call, passing `param`, to the IPC server running at `address` which is servicing the `protocol` protocol, with the `ticket` credentials, `rpcTimeout` as timeout and `conf` as configuration for this connection, returning the value.
`static VersionedProtocol`	`RPC.getProxy(Class<? extends VersionedProtocol> protocol, long clientVersion, InetSocketAddress addr, Configuration conf)` Construct a client-side proxy object with the default SocketFactory
`static VersionedProtocol`	`RPC.getProxy(Class<? extends VersionedProtocol> protocol, long clientVersion, InetSocketAddress addr, Configuration conf, int rpcTimeout)`
`static VersionedProtocol`	`RPC.getProxy(Class<? extends VersionedProtocol> protocol, long clientVersion, InetSocketAddress addr, Configuration conf, SocketFactory factory)` Construct a client-side proxy object that implements the named protocol, talking to a server at the named address.
`static VersionedProtocol`	`RPC.getProxy(Class<? extends VersionedProtocol> protocol, long clientVersion, InetSocketAddress addr, Configuration conf, SocketFactory factory, int rpcTimeout)` Construct a client-side proxy object that implements the named protocol, talking to a server at the named address.
`static VersionedProtocol`	`RPC.getProxy(Class<? extends VersionedProtocol> protocol, long clientVersion, InetSocketAddress addr, UserGroupInformation ticket, Configuration conf, SocketFactory factory)` Construct a client-side proxy object that implements the named protocol, talking to a server at the named address.
`static VersionedProtocol`	`RPC.getProxy(Class<? extends VersionedProtocol> protocol, long clientVersion, InetSocketAddress addr, UserGroupInformation ticket, Configuration conf, SocketFactory factory, int rpcTimeout)` Construct a client-side proxy object that implements the named protocol, talking to a server at the named address.
`static VersionedProtocol`	`RPC.getProxy(Class<? extends VersionedProtocol> protocol, long clientVersion, InetSocketAddress addr, UserGroupInformation ticket, Configuration conf, SocketFactory factory, int rpcTimeout, RetryPolicy connectionRetryPolicy, boolean checkVersion)` Construct a client-side proxy object that implements the named protocol, talking to a server at the named address.
`static RPC.Server`	`RPC.getServer(Object instance, String bindAddress, int port, Configuration conf)` Construct a server for a protocol implementation instance listening on a port and address.
`static RPC.Server`	`RPC.getServer(Object instance, String bindAddress, int port, int numHandlers, boolean verbose, Configuration conf)` Construct a server for a protocol implementation instance listening on a port and address.
`static RPC.Server`	`RPC.getServer(Object instance, String bindAddress, int port, int numHandlers, boolean verbose, Configuration conf, SecretManager<? extends TokenIdentifier> secretManager)` Construct a server for a protocol implementation instance listening on a port and address, with a secret manager.
`static int`	`Client.getTimeout(Configuration conf)` The time after which a RPC will timeout.
`static void`	`Client.setPingInterval(Configuration conf, int pingInterval)` set the ping interval value in configuration
`static VersionedProtocol`	`RPC.waitForProxy(Class<? extends VersionedProtocol> protocol, long clientVersion, InetSocketAddress addr, Configuration conf)`

Constructors in org.apache.hadoop.ipc with parameters of type Configuration
`Client(Class<? extends Writable> valueClass, Configuration conf)` Construct an IPC client with the default SocketFactory
`Client(Class<? extends Writable> valueClass, Configuration conf, SocketFactory factory)` Construct an IPC client whose values are of the given `Writable` class.
`RPC.Server(Object instance, Configuration conf, String bindAddress, int port)` Construct an RPC server.
`RPC.Server(Object instance, Configuration conf, String bindAddress, int port, int numHandlers, boolean verbose, SecretManager<? extends TokenIdentifier> secretManager)` Construct an RPC server.
`Server(String bindAddress, int port, Class<? extends Writable> paramClass, int handlerCount, Configuration conf)`
`Server(String bindAddress, int port, Class<? extends Writable> paramClass, int handlerCount, Configuration conf, String serverName)`
`Server(String bindAddress, int port, Class<? extends Writable> paramClass, int handlerCount, Configuration conf, String serverName, SecretManager<? extends TokenIdentifier> secretManager)` Constructs a server listening on the named port and address.

Uses of Configuration in org.apache.hadoop.mapred

Subclasses of Configuration in org.apache.hadoop.mapred
`class`	`JobConf` A map/reduce job configuration.

Fields in org.apache.hadoop.mapred declared as Configuration
`protected Configuration`	`SequenceFileRecordReader.conf`

Methods in org.apache.hadoop.mapred that return Configuration
`Configuration`	`Task.getConf()`
`Configuration`	`SequenceFileInputFilter.FilterBase.getConf()`
`Configuration`	`TaskController.getConf()`

Methods in org.apache.hadoop.mapred with parameters of type Configuration

void UserLogCleaner.addOldUserLogsForDeletion(File loc, Configuration conf)
Adds the job log directories for deletion with default retain hours.

void JobClient.Renewer.cancel(Token<?> token, Configuration conf)

void UserLogCleaner.clearOldUserLogs(Configuration conf)
Clears all the logs in userlogs directory.

protected static



<INKEY,INVALUE,OUTKEY,OUTVALUE> 


Reducer.Context

Task.createReduceContext(Reducer<INKEY,INVALUE,OUTKEY,OUTVALUE> reducer,
                    Configuration job,
                    TaskAttemptID taskId,
                    RawKeyValueIterator rIter,
                    Counter inputKeyCounter,
                    Counter inputValueCounter,
                    RecordWriter<OUTKEY,OUTVALUE> output,
                    OutputCommitter committer,
                    StatusReporter reporter,
                    RawComparator<INKEY> comparator,
                    Class<INKEY> keyClass,
                    Class<INVALUE> valueClass)

static long[] JobLocalizer.downloadPrivateCache(Configuration conf)
Download the parts of the distributed cache that are private.

static InetSocketAddress JobTracker.getAddress(Configuration conf)

static int SkipBadRecords.getAttemptsToStartSkipping(Configuration conf)
Get the number of Task attempts AFTER which skip mode will be kicked off.

static boolean SkipBadRecords.getAutoIncrMapperProcCount(Configuration conf)
Get the flag which if set to true, SkipBadRecords.COUNTER_MAP_PROCESSED_RECORDS is incremented by MapRunner after invoking the map function.

static boolean SkipBadRecords.getAutoIncrReducerProcCount(Configuration conf)
Get the flag which if set to true, SkipBadRecords.COUNTER_REDUCE_PROCESSED_GROUPS is incremented by framework after invoking the reduce function.

protected static FileSystem.Statistics Task.getFsStatistics(Path path, Configuration conf)
Gets a handle to the Statistics instance based on the scheme associated with path.

static long SkipBadRecords.getMapperMaxSkipRecords(Configuration conf)
Get the number of acceptable skip records surrounding the bad record PER bad record in mapper.

static SequenceFile.Reader[] SequenceFileOutputFormat.getReaders(Configuration conf, Path dir)
Open the output generated by this format.

static MapFile.Reader[] MapFileOutputFormat.getReaders(FileSystem ignored, Path dir, Configuration conf)
Open the output generated by this format.

static long SkipBadRecords.getReducerMaxSkipGroups(Configuration conf)
Get the number of acceptable skip groups surrounding the bad group PER bad group in reducer.

static Path SkipBadRecords.getSkipOutputPath(Configuration conf)
Get the directory to which skipped records are written.

static String JobHistory.JobInfo.getWorkflowAdjacencies(Configuration conf)
Get the workflow adjacencies from the job conf The string returned is of the form "key"="value" "key"="value" ...

long JobClient.Renewer.renew(Token<?> token, Configuration conf)

static void SkipBadRecords.setAttemptsToStartSkipping(Configuration conf, int attemptsToStartSkipping)
Set the number of Task attempts AFTER which skip mode will be kicked off.

static void SkipBadRecords.setAutoIncrMapperProcCount(Configuration conf, boolean autoIncr)
Set the flag which if set to true, SkipBadRecords.COUNTER_MAP_PROCESSED_RECORDS is incremented by MapRunner after invoking the map function.

static void SkipBadRecords.setAutoIncrReducerProcCount(Configuration conf, boolean autoIncr)
Set the flag which if set to true, SkipBadRecords.COUNTER_REDUCE_PROCESSED_GROUPS is incremented by framework after invoking the reduce function.

void Task.setConf(Configuration conf)

void SequenceFileInputFilter.RegexFilter.setConf(Configuration conf)
configure the Filter by checking the configuration

void SequenceFileInputFilter.PercentFilter.setConf(Configuration conf)
configure the filter by checking the configuration

void SequenceFileInputFilter.MD5Filter.setConf(Configuration conf)
configure the filter according to configuration

void TaskController.setConf(Configuration conf)

void DefaultTaskController.setConf(Configuration conf)

static void SequenceFileInputFilter.setFilterClass(Configuration conf, Class filterClass)
set the filter class

static void SequenceFileInputFilter.PercentFilter.setFrequency(Configuration conf, int frequency)
set the frequency and stores it in conf

static void SequenceFileInputFilter.MD5Filter.setFrequency(Configuration conf, int frequency)
set the filtering frequency in configuration

static void SkipBadRecords.setMapperMaxSkipRecords(Configuration conf, long maxSkipRecs)
Set the number of acceptable skip records surrounding the bad record PER bad record in mapper.

static void SequenceFileInputFilter.RegexFilter.setPattern(Configuration conf, String regex)
Define the filtering regex and stores it in conf

static void SkipBadRecords.setReducerMaxSkipGroups(Configuration conf, long maxSkipGrps)
Set the number of acceptable skip groups surrounding the bad group PER bad group in reducer.

Constructors in org.apache.hadoop.mapred with parameters of type Configuration
`HDFSMonitorThread(Configuration conf, JobTracker jt, FileSystem fs)`
`JobClient(InetSocketAddress jobTrackAddr, Configuration conf)` Build a job client, connect to the indicated job tracker.
`JobConf(Configuration conf)` Construct a map/reduce job configuration.
`JobConf(Configuration conf, Class exampleClass)` Construct a map/reduce job configuration.
`KeyValueLineRecordReader(Configuration job, FileSplit split)`
`LineRecordReader.LineReader(InputStream in, Configuration conf)` Deprecated.
`LineRecordReader(Configuration job, FileSplit split)`
`LineRecordReader(InputStream in, long offset, long endOffset, Configuration job)`
`SequenceFileAsBinaryInputFormat.SequenceFileAsBinaryRecordReader(Configuration conf, FileSplit split)`
`SequenceFileAsTextRecordReader(Configuration conf, FileSplit split)`
`SequenceFileRecordReader(Configuration conf, FileSplit split)`
`Task.CombineOutputCollector(Counters.Counter outCounter, Progressable progressable, Configuration conf)`
`Task.CombineValuesIterator(RawKeyValueIterator in, RawComparator<KEY> comparator, Class<KEY> keyClass, Class<VALUE> valClass, Configuration conf, Reporter reporter, Counters.Counter combineInputCounter)`
`TaskLogsTruncater(Configuration conf)`
`UserLogCleaner(UserLogManager userLogManager, Configuration conf)`

Uses of Configuration in org.apache.hadoop.mapred.join

Methods in org.apache.hadoop.mapred.join that return Configuration
`Configuration`	`CompositeRecordReader.getConf()` Return the configuration used by this object.

Methods in org.apache.hadoop.mapred.join with parameters of type Configuration
`void`	`CompositeRecordReader.setConf(Configuration conf)` Set the configuration to be used by this object.

Uses of Configuration in org.apache.hadoop.mapred.lib

Methods in org.apache.hadoop.mapred.lib that return Configuration
`Configuration`	`InputSampler.getConf()`

Methods in org.apache.hadoop.mapred.lib with parameters of type Configuration
`void`	`InputSampler.setConf(Configuration conf)`

Uses of Configuration in org.apache.hadoop.mapred.pipes

Constructors in org.apache.hadoop.mapred.pipes with parameters of type Configuration
`Submitter(Configuration conf)`

Uses of Configuration in org.apache.hadoop.mapred.tools

Constructors in org.apache.hadoop.mapred.tools with parameters of type Configuration
`MRAdmin(Configuration conf)`

Uses of Configuration in org.apache.hadoop.mapreduce

Methods in org.apache.hadoop.mapreduce that return Configuration
`Configuration`	`JobContext.getConfiguration()` Return the configuration for the job.

Methods in org.apache.hadoop.mapreduce with parameters of type Configuration
`static Job`	`Job.getInstance(Configuration conf)` Creates a new `Job` with a given `Configuration`.
`static Job`	`Job.getInstance(Configuration conf, String jobName)` Creates a new `Job` with a given `Configuration` and a given jobName.
`static Path`	`JobSubmissionFiles.getStagingDir(JobClient client, Configuration conf)` Initializes the staging directory and returns the path.

Constructors in org.apache.hadoop.mapreduce with parameters of type Configuration
`Job(Configuration conf)`
`Job(Configuration conf, String jobName)`
`JobContext(Configuration conf, JobID jobId)`
`MapContext(Configuration conf, TaskAttemptID taskid, RecordReader<KEYIN,VALUEIN> reader, RecordWriter<KEYOUT,VALUEOUT> writer, OutputCommitter committer, StatusReporter reporter, InputSplit split)`
`Mapper.Context(Configuration conf, TaskAttemptID taskid, RecordReader<KEYIN,VALUEIN> reader, RecordWriter<KEYOUT,VALUEOUT> writer, OutputCommitter committer, StatusReporter reporter, InputSplit split)`
`ReduceContext(Configuration conf, TaskAttemptID taskid, RawKeyValueIterator input, Counter inputKeyCounter, Counter inputValueCounter, RecordWriter<KEYOUT,VALUEOUT> output, OutputCommitter committer, StatusReporter reporter, RawComparator<KEYIN> comparator, Class<KEYIN> keyClass, Class<VALUEIN> valueClass)`
`Reducer.Context(Configuration conf, TaskAttemptID taskid, RawKeyValueIterator input, Counter inputKeyCounter, Counter inputValueCounter, RecordWriter<KEYOUT,VALUEOUT> output, OutputCommitter committer, StatusReporter reporter, RawComparator<KEYIN> comparator, Class<KEYIN> keyClass, Class<VALUEIN> valueClass)`
`TaskAttemptContext(Configuration conf, TaskAttemptID taskId)`
`TaskInputOutputContext(Configuration conf, TaskAttemptID taskid, RecordWriter<KEYOUT,VALUEOUT> output, OutputCommitter committer, StatusReporter reporter)`

Uses of Configuration in org.apache.hadoop.mapreduce.lib.db

Methods in org.apache.hadoop.mapreduce.lib.db that return Configuration
`Configuration`	`DBInputFormat.getConf()`
`Configuration`	`DBConfiguration.getConf()`

Methods in org.apache.hadoop.mapreduce.lib.db with parameters of type Configuration
`static void`	`DBConfiguration.configureDB(Configuration job, String driverClass, String dbUrl)` Sets the DB access related fields in the JobConf.
`static void`	`DBConfiguration.configureDB(Configuration conf, String driverClass, String dbUrl, String userName, String passwd)` Sets the DB access related fields in the `Configuration`.
`protected RecordReader<LongWritable,T>`	`DBInputFormat.createDBRecordReader(DBInputFormat.DBInputSplit split, Configuration conf)`
`protected RecordReader<LongWritable,T>`	`OracleDataDrivenDBInputFormat.createDBRecordReader(DBInputFormat.DBInputSplit split, Configuration conf)`
`protected RecordReader<LongWritable,T>`	`DataDrivenDBInputFormat.createDBRecordReader(DBInputFormat.DBInputSplit split, Configuration conf)`
`static void`	`DataDrivenDBInputFormat.setBoundingQuery(Configuration conf, String query)` Set the user-defined bounding query to use with a user-defined query.
`void`	`DBInputFormat.setConf(Configuration conf)` Set the configuration to be used by this object.
`static void`	`OracleDBRecordReader.setSessionTimeZone(Configuration conf, Connection conn)` Set session time zone
`List<InputSplit>`	`DateSplitter.split(Configuration conf, ResultSet results, String colName)`
`List<InputSplit>`	`BooleanSplitter.split(Configuration conf, ResultSet results, String colName)`
`List<InputSplit>`	`DBSplitter.split(Configuration conf, ResultSet results, String colName)` Given a ResultSet containing one record (and already advanced to that record) with two columns (a low value, and a high value, both of the same type), determine a set of splits that span the given values.
`List<InputSplit>`	`FloatSplitter.split(Configuration conf, ResultSet results, String colName)`
`List<InputSplit>`	`TextSplitter.split(Configuration conf, ResultSet results, String colName)` This method needs to determine the splits between two user-provided strings.
`List<InputSplit>`	`IntegerSplitter.split(Configuration conf, ResultSet results, String colName)`
`List<InputSplit>`	`BigDecimalSplitter.split(Configuration conf, ResultSet results, String colName)`

Constructors in org.apache.hadoop.mapreduce.lib.db with parameters of type Configuration
`DataDrivenDBRecordReader(DBInputFormat.DBInputSplit split, Class<T> inputClass, Configuration conf, Connection conn, DBConfiguration dbConfig, String cond, String[] fields, String table, String dbProduct)`
`DBConfiguration(Configuration job)`
`DBRecordReader(DBInputFormat.DBInputSplit split, Class<T> inputClass, Configuration conf, Connection conn, DBConfiguration dbConfig, String cond, String[] fields, String table)`
`MySQLDataDrivenDBRecordReader(DBInputFormat.DBInputSplit split, Class<T> inputClass, Configuration conf, Connection conn, DBConfiguration dbConfig, String cond, String[] fields, String table)`
`MySQLDBRecordReader(DBInputFormat.DBInputSplit split, Class<T> inputClass, Configuration conf, Connection conn, DBConfiguration dbConfig, String cond, String[] fields, String table)`
`OracleDataDrivenDBRecordReader(DBInputFormat.DBInputSplit split, Class<T> inputClass, Configuration conf, Connection conn, DBConfiguration dbConfig, String cond, String[] fields, String table)`
`OracleDBRecordReader(DBInputFormat.DBInputSplit split, Class<T> inputClass, Configuration conf, Connection conn, DBConfiguration dbConfig, String cond, String[] fields, String table)`

Uses of Configuration in org.apache.hadoop.mapreduce.lib.input

Fields in org.apache.hadoop.mapreduce.lib.input declared as Configuration
`protected Configuration`	`SequenceFileRecordReader.conf`

Methods in org.apache.hadoop.mapreduce.lib.input that return Configuration
`Configuration`	`SequenceFileInputFilter.FilterBase.getConf()`

Methods in org.apache.hadoop.mapreduce.lib.input with parameters of type Configuration
`static List<FileSplit>`	`NLineInputFormat.getSplitsForFile(FileStatus status, Configuration conf, int numLinesPerSplit)`
`void`	`SequenceFileInputFilter.RegexFilter.setConf(Configuration conf)` configure the Filter by checking the configuration
`void`	`SequenceFileInputFilter.PercentFilter.setConf(Configuration conf)` configure the filter by checking the configuration
`void`	`SequenceFileInputFilter.MD5Filter.setConf(Configuration conf)` configure the filter according to configuration
`static void`	`SequenceFileInputFilter.PercentFilter.setFrequency(Configuration conf, int frequency)` set the frequency and stores it in conf
`static void`	`SequenceFileInputFilter.MD5Filter.setFrequency(Configuration conf, int frequency)` set the filtering frequency in configuration
`static void`	`SequenceFileInputFilter.RegexFilter.setPattern(Configuration conf, String regex)` Define the filtering regex and stores it in conf

Constructors in org.apache.hadoop.mapreduce.lib.input with parameters of type Configuration
`KeyValueLineRecordReader(Configuration conf)`

Uses of Configuration in org.apache.hadoop.mapreduce.lib.jobcontrol

Constructors in org.apache.hadoop.mapreduce.lib.jobcontrol with parameters of type Configuration
`ControlledJob(Configuration conf)` Construct a job.

Uses of Configuration in org.apache.hadoop.mapreduce.lib.partition

Methods in org.apache.hadoop.mapreduce.lib.partition that return Configuration
`Configuration`	`KeyFieldBasedComparator.getConf()`
`Configuration`	`TotalOrderPartitioner.getConf()`
`Configuration`	`KeyFieldBasedPartitioner.getConf()`
`Configuration`	`BinaryPartitioner.getConf()`

Methods in org.apache.hadoop.mapreduce.lib.partition with parameters of type Configuration
`static String`	`TotalOrderPartitioner.getPartitionFile(Configuration conf)` Get the path to the SequenceFile storing the sorted partition keyset.
`void`	`KeyFieldBasedComparator.setConf(Configuration conf)`
`void`	`TotalOrderPartitioner.setConf(Configuration conf)` Read in the partition file and build indexing data structures.
`void`	`KeyFieldBasedPartitioner.setConf(Configuration conf)`
`void`	`BinaryPartitioner.setConf(Configuration conf)`
`static void`	`BinaryPartitioner.setLeftOffset(Configuration conf, int offset)` Set the subarray to be used for partitioning to `bytes[offset:]` in Python syntax.
`static void`	`BinaryPartitioner.setOffsets(Configuration conf, int left, int right)` Set the subarray to be used for partitioning to `bytes[left:(right+1)]` in Python syntax.
`static void`	`TotalOrderPartitioner.setPartitionFile(Configuration conf, Path p)` Set the path to the SequenceFile storing the sorted partition keyset.
`static void`	`BinaryPartitioner.setRightOffset(Configuration conf, int offset)` Set the subarray to be used for partitioning to `bytes[:(offset+1)]` in Python syntax.

Constructors in org.apache.hadoop.mapreduce.lib.partition with parameters of type Configuration
`InputSampler(Configuration conf)`

Uses of Configuration in org.apache.hadoop.mapreduce.security

Methods in org.apache.hadoop.mapreduce.security with parameters of type Configuration
`static void`	`TokenCache.cleanUpTokenReferral(Configuration conf)` Remove jobtoken referrals which don't make sense in the context of the task execution.
`static Credentials`	`TokenCache.loadTokens(String jobTokenFile, Configuration conf)` load job token from a file
`static void`	`TokenCache.obtainTokensForNamenodes(Credentials credentials, Path[] ps, Configuration conf)` Convenience method to obtain delegation tokens from namenodes corresponding to the paths passed.

Uses of Configuration in org.apache.hadoop.mapreduce.security.token

Methods in org.apache.hadoop.mapreduce.security.token with parameters of type Configuration
`static void`	`DelegationTokenRenewal.registerDelegationTokensForRenewal(JobID jobId, Credentials ts, Configuration conf)`

Uses of Configuration in org.apache.hadoop.mapreduce.server.tasktracker.userlogs

Methods in org.apache.hadoop.mapreduce.server.tasktracker.userlogs with parameters of type Configuration
`void`	`UserLogManager.clearOldUserLogs(Configuration conf)` Called during TaskTracker restart/re-init.

Constructors in org.apache.hadoop.mapreduce.server.tasktracker.userlogs with parameters of type Configuration
`UserLogManager(Configuration conf)` Create the user log manager to manage user logs on `TaskTracker`.
`UserLogManager(Configuration conf, TaskController taskController)` Create the user log manager to manage user logs on `TaskTracker`.

Uses of Configuration in org.apache.hadoop.mapreduce.split

Methods in org.apache.hadoop.mapreduce.split with parameters of type Configuration

static void JobSplitWriter.createSplitFiles(Path jobSubmitDir, Configuration conf, FileSystem fs, InputSplit[] splits)

static



<T extends InputSplit> 


void

JobSplitWriter.createSplitFiles(Path jobSubmitDir,
                 Configuration conf,
                 FileSystem fs,
                 List<InputSplit> splits)

static



<T extends InputSplit> 


void

JobSplitWriter.createSplitFiles(Path jobSubmitDir,
                 Configuration conf,
                 FileSystem fs,
                 T[] splits)

static JobSplit.TaskSplitMetaInfo[] SplitMetaInfoReader.readSplitMetaInfo(JobID jobId, FileSystem fs, Configuration conf, Path jobSubmitDir)

Uses of Configuration in org.apache.hadoop.net

Methods in org.apache.hadoop.net that return Configuration
`Configuration`	`ScriptBasedMapping.getConf()`
`Configuration`	`SocksSocketFactory.getConf()`

Methods in org.apache.hadoop.net with parameters of type Configuration
`static SocketFactory`	`NetUtils.getDefaultSocketFactory(Configuration conf)` Get the default socket factory as specified by the configuration parameter `hadoop.rpc.socket.factory.default`
`static NetworkTopology`	`NetworkTopology.getInstance(Configuration conf)` Get an instance of NetworkTopology based on the value of the configuration parameter net.topology.impl.
`static String`	`NetUtils.getServerAddress(Configuration conf, String oldBindAddressName, String oldPortName, String newBindAddressName)` Deprecated.
`static SocketFactory`	`NetUtils.getSocketFactory(Configuration conf, Class<?> clazz)` Get the socket factory for the given class according to its configuration parameter `hadoop.rpc.socket.factory.class.<ClassName>`.
`static SocketFactory`	`NetUtils.getSocketFactoryFromProperty(Configuration conf, String propValue)` Get the socket factory corresponding to the given proxy URI.
`void`	`ScriptBasedMapping.setConf(Configuration conf)`
`void`	`SocksSocketFactory.setConf(Configuration conf)`

Constructors in org.apache.hadoop.net with parameters of type Configuration
`ScriptBasedMapping(Configuration conf)`

Uses of Configuration in org.apache.hadoop.security

Methods in org.apache.hadoop.security with parameters of type Configuration
`static AccessControlList`	`SecurityUtil.getAdminAcls(Configuration conf, String configKey)` Get the ACL object representing the cluster administrators The user who starts the daemon is automatically added as an admin
`static Groups`	`Groups.getUserToGroupsMappingService(Configuration conf)`
`static void`	`SaslRpcServer.init(Configuration conf)`
`void`	`AuthenticationFilterInitializer.initFilter(FilterContainer container, Configuration conf)` Initializes Alfredo AuthenticationFilter.
`static void`	`SecurityUtil.login(Configuration conf, String keytabFileKey, String userNameKey)` If a keytab has been provided, login as that user.
`static void`	`SecurityUtil.login(Configuration conf, String keytabFileKey, String userNameKey, String hostname)` If a keytab has been provided, login as that user.
`static Credentials`	`Credentials.readTokenStorageFile(Path filename, Configuration conf)` Convenience method for reading a token storage file, and loading the Tokens therein in the passed UGI
`static void`	`KerberosName.setConfiguration(Configuration conf)` Set the static configuration to get the rules.
`static void`	`UserGroupInformation.setConfiguration(Configuration conf)` Set the static configuration for UGI.
`void`	`Credentials.writeTokenStorageFile(Path filename, Configuration conf)`

Constructors in org.apache.hadoop.security with parameters of type Configuration
`Groups(Configuration conf)`

Uses of Configuration in org.apache.hadoop.security.authorize

Methods in org.apache.hadoop.security.authorize with parameters of type Configuration
`static void`	`ServiceAuthorizationManager.authorize(UserGroupInformation user, Class<?> protocol, Configuration conf, InetAddress addr)` Authorize the user to access the protocol being used.
`static void`	`ProxyUsers.authorize(UserGroupInformation user, String remoteAddress, Configuration newConf)` Authorize the superuser which is doing doAs
`static void`	`ServiceAuthorizationManager.refresh(Configuration conf, PolicyProvider provider)`
`static void`	`ProxyUsers.refreshSuperUserGroupsConfiguration(Configuration conf)` refresh configuration

Uses of Configuration in org.apache.hadoop.security.token

Methods in org.apache.hadoop.security.token with parameters of type Configuration
`void`	`Token.cancel(Configuration conf)` Cancel this delegation token
`void`	`Token.TrivialRenewer.cancel(Token<?> token, Configuration conf)`
`abstract void`	`TokenRenewer.cancel(Token<?> token, Configuration conf)` Cancel the given token
`long`	`Token.renew(Configuration conf)` Renew this delegation token
`long`	`Token.TrivialRenewer.renew(Token<?> token, Configuration conf)`
`abstract long`	`TokenRenewer.renew(Token<?> token, Configuration conf)` Renew the given token.

Uses of Configuration in org.apache.hadoop.streaming

Fields in org.apache.hadoop.streaming declared as Configuration
`protected Configuration`	`StreamJob.config_`

Methods in org.apache.hadoop.streaming that return Configuration
`Configuration`	`LoadTypedBytes.getConf()`
`Configuration`	`DumpTypedBytes.getConf()`
`Configuration`	`StreamJob.getConf()`
`Configuration`	`PipeMapRed.getConfiguration()` Returns the Configuration.

Methods in org.apache.hadoop.streaming with parameters of type Configuration
`static Class`	`StreamUtil.goodClassOrNull(Configuration conf, String className, String defaultPackage)` It may seem strange to silently switch behaviour when a String is not a classname; the reason is simplified Usage:
`void`	`LoadTypedBytes.setConf(Configuration conf)`
`void`	`DumpTypedBytes.setConf(Configuration conf)`
`void`	`StreamJob.setConf(Configuration conf)`

Constructors in org.apache.hadoop.streaming with parameters of type Configuration
`DumpTypedBytes(Configuration conf)`
`LoadTypedBytes(Configuration conf)`

Uses of Configuration in org.apache.hadoop.typedbytes

Methods in org.apache.hadoop.typedbytes that return Configuration
`Configuration`	`TypedBytesWritableInput.getConf()`

Methods in org.apache.hadoop.typedbytes with parameters of type Configuration
`void`	`TypedBytesWritableInput.setConf(Configuration conf)`

Uses of Configuration in org.apache.hadoop.util

Methods in org.apache.hadoop.util that return Configuration
`Configuration`	`GenericOptionsParser.getConfiguration()` Get the modified configuration

Methods in org.apache.hadoop.util with parameters of type Configuration

static



<T> T

ReflectionUtils.copy(Configuration conf,
     T src,
     T dst)

Make a copy of the writable object using serialization to a buffer

static URL[] GenericOptionsParser.getLibJars(Configuration conf)
If libjars are set in the conf, parse the libjars.

boolean NativeCodeLoader.getLoadNativeLibraries(Configuration conf)
Return if native hadoop libraries, if present, can be used for this job.

static MemoryCalculatorPlugin MemoryCalculatorPlugin.getMemoryCalculatorPlugin(Class<? extends MemoryCalculatorPlugin> clazz, Configuration conf)
Deprecated. Get the MemoryCalculatorPlugin from the class name and configure it.

static ResourceCalculatorPlugin ResourceCalculatorPlugin.getResourceCalculatorPlugin(Class<? extends ResourceCalculatorPlugin> clazz, Configuration conf)
Get the ResourceCalculatorPlugin from the class name and configure it.

static String[] Shell.getUlimitMemoryCommand(Configuration conf)
Deprecated. Use Shell.getUlimitMemoryCommand(int)

static



<T> T

ReflectionUtils.newInstance(Class<T> theClass,
            Configuration conf)

Create an object for the given class and initialize it from conf

static int ToolRunner.run(Configuration conf, Tool tool, String[] args)
Runs the given Tool by Tool.run(String[]), after parsing with the given generic arguments.

static void ReflectionUtils.setConf(Object theObject, Configuration conf)
Check and set 'configuration' if necessary.

void NativeCodeLoader.setLoadNativeLibraries(Configuration conf, boolean loadNativeLibraries)
Set if native hadoop libraries, if present, can be used for this job.

Constructors in org.apache.hadoop.util with parameters of type Configuration
`GenericOptionsParser(Configuration conf, org.apache.commons.cli.Options options, String[] args)` Create a `GenericOptionsParser` to parse given options as well as generic Hadoop options.
`GenericOptionsParser(Configuration conf, String[] args)` Create a `GenericOptionsParser to parse only the generic Hadoop arguments.`
`LineReader(InputStream in, Configuration conf)` Create a line reader that reads from the given stream using the `io.file.buffer.size` specified in the given `Configuration`.
`LineReader(InputStream in, Configuration conf, byte[] recordDelimiterBytes)` Create a line reader that reads from the given stream using the `io.file.buffer.size` specified in the given `Configuration`, and using a custom delimiter of array of bytes.

Uses of Configuration in org.apache.hadoop.util.hash

Methods in org.apache.hadoop.util.hash with parameters of type Configuration
`static int`	`Hash.getHashType(Configuration conf)` This utility method converts the name of the configured hash type to a symbolic constant.
`static Hash`	`Hash.getInstance(Configuration conf)` Get a singleton instance of hash function of a type defined in the configuration.