Ziggy 0.1.3.1

HDMC

HDMC provides 3 principle means of interacting with a Hadoop server. Import it using import ziggy.hdmc. The interaction types are:

• Call Assembly

  Building custom and executing Hadoop streaming calls. This is done using the build_generic_hadoop_call, execute and execute_and_wait methods.

• Monte Carlo Mapping

  Running Monte Carlo-type operations by providing only a mapping script and a number of iterations. This is done using the submit_inline and submit methods.

• Data/Argument Distribution

  Processing several datafiles or a list of arguments in parallel across mappers. This is done using the submit_checkpoint_inline and the submit_checkpoint methods.

It should be noted that Monte Carlo Mapping and Data Distribution very much violate the spirit of Hadoop. However, they do provide a very simple way to mimic traditional compute-cluster tasks without the need for cluster management along the lines of SGE or Torque. Similarly, they don’t require a real cluster, just a Hadoop installation.

HDFS

Ziggy provides methods for interacting with the HDFS distributed filesystem from within Python. These methods can be accessed by importing, for example, import ziggy.hdmc.hdfs Method calls mimic those found under hadoop dfs.

Utilities

Ziggy provides a number of simple utilities for manipulating very large datasets with Hadoop. Utilities provided include: search, grep, numeric sort, and ascii sort. Each of these is accessed under ziggy.util. Note ziggy.util.search provides file names and line numbers a number of files in an HDFS directory or file. ziggy.util.grep provides the lines themselves.

GraphReduce

While Hadoop’s Map/Reduce paradigm is poorly suited to graph algorithms, the GraphReduce modules allow for certain graph analyses on a Hadoop Cluster. Currently analyes are limited to: degree-based measures, shortest-path based measures, page-rank measures, and connected-component measures. Except for page-rank, all path-derived measures rely on parallel breadth-first search. See the Epydoc documentation for more information. GraphReduce can be accessed by importing ziggy.GraphReduce

Examples

Building a custom Hadoop streaming call:

import ziggy.hdmc as hdmc
import ziggy.hdmc.hdfs as hdfs
#load data to hdfs
hdfs.copyToHDFS(localfilename, hfds_input_filename)
mapper = '/path/to/mapper.py'
reducer = '/path/to/reducer.py'
output_filename ='hdfs_relative/output_filename'
supporting_files = [list,of,files,mappers,require]
maps = 20
hadoop_call = hdmc.build_generic_hadoop_call(mapper, reducer, hdfs_input_filename, output_filename, supporting_files, maps)
hdmc.execute_and_wait(hadoop_call)

Building a Monte Carlo Job:

import ziggy.hdmc as hdmc
mapper = '/path/to/job_with_needs_to_be_done_many_times.py'
iterations = 1000
output_file = 'output_filename'
hdmc.submit_inline(mapper, output_file, iterations)

Building a Task Distribution Job:

import ziggy.hdmc as hdmc
url_list = [a, list, of, url, strings]
mapper = '/path/to/script/which/takes/a/url/as/sys.argv[1].py'
output_filename = 'output_file_name'
supporting_files = []
hdmc.submit_checkpoint_inline(mapper, output_filename, url_list, supporting_files, files=False)

Building a Data Distribution Job:

import ziggy.hdmc as hdmc
file_list = [a, list, of, filenames, usually, provided, by, glob]
mapper = '/path/to/script/which/takes/a/filename/as/sys.argv[1].py'
output_filename = 'output_file_name'
supporting_files = [filenames, my, mapper,needs]
hdmc.submit_checkpoint_inline(mapper, output_filename, file_list, supporting_files, files=True)