logstash-input-ganglia 0.1.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YjIwMzM4ZDRkZDgxOGViZTEyNjNkMmYyNzg5MGI1MDAzNWM4MDUzZQ==
+  data.tar.gz: !binary |-
+    YmI1Njg0ZWRhMDFiNDRlMDJhZDk2NWZmMzYyYzQ4ZWUzZDZiMjUzNQ==
+SHA512:
+  metadata.gz: !binary |-
+    ZjY2ZDAxMTJhNDdiMzEzMDhlMDFhODQyN2VkOTViYTkzOWM0ODk4MzVhMGUx
+    ZDgyOTgyM2JjMzk4ZTM4ZDBmMjI3NDI0OWY5OWRjNGI4NDM1MTZhYjc5MGE5
+    NGM3ZTljZmZkNDU0NzY2NzhlNmY4MmM0ZWFhMzUzM2E5OTU5ZmI=
+  data.tar.gz: !binary |-
+    ZmFiMzA2ZWQ0NjgxOGMxZGM2NDRmYmU2NWE1MzhjNmExOTI2ZDU4MjlhNTNh
+    ZTlmNTQ1NGU3OWMxMjIwNTIyNTI2YzljYWIyMWIxYThlNWFjYWU1MTIwZGFk
+    YTE4OTVjOGUzMzU4YWJiZjQ0MzlkMDdiZDQ1YTdmYWExMDdkMDg=

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+Gemfile.lock
+.bundle
+vendor

data/Gemfile

@@ -0,0 +1,4 @@
+source 'http://rubygems.org'
+gem 'rake'
+gem 'gem_publisher'
+gem 'archive-tar-minitar'

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright (c) 2012-2014 Elasticsearch <http://www.elasticsearch.org>
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/Rakefile

@@ -0,0 +1,6 @@
+@files=[]
+
+task :default do
+  system("rake -T")
+end
+

data/lib/logstash/inputs/ganglia.rb

@@ -0,0 +1,127 @@
+# encoding: utf-8
+require "date"
+require "logstash/filters/grok"
+require "logstash/filters/date"
+require "logstash/inputs/ganglia/gmondpacket"
+require "logstash/inputs/base"
+require "logstash/namespace"
+require "socket"
+
+# Read ganglia packets from the network via udp
+#
+class LogStash::Inputs::Ganglia < LogStash::Inputs::Base
+  config_name "ganglia"
+  milestone 1
+
+  default :codec, "plain"
+
+  # The address to listen on
+  config :host, :validate => :string, :default => "0.0.0.0"
+
+  # The port to listen on. Remember that ports less than 1024 (privileged
+  # ports) may require root to use.
+  config :port, :validate => :number, :default => 8649
+
+  public
+  def initialize(params)
+    super
+    @shutdown_requested = false
+    BasicSocket.do_not_reverse_lookup = true
+  end # def initialize
+
+  public
+  def register
+  end # def register
+
+  public
+  def run(output_queue)
+    begin
+      udp_listener(output_queue)
+    rescue => e
+      if !@shutdown_requested
+        @logger.warn("ganglia udp listener died",
+                     :address => "#{@host}:#{@port}", :exception => e,
+        :backtrace => e.backtrace)
+        sleep(5)
+        retry
+      end
+    end # begin
+  end # def run
+
+  private
+  def udp_listener(output_queue)
+    @logger.info("Starting ganglia udp listener", :address => "#{@host}:#{@port}")
+
+    if @udp
+      @udp.close_read
+      @udp.close_write
+    end
+
+    @udp = UDPSocket.new(Socket::AF_INET)
+    @udp.bind(@host, @port)
+
+    @metadata = Hash.new if @metadata.nil?
+    loop do
+      packet, client = @udp.recvfrom(9000)
+      # TODO(sissel): make this a codec...
+      e = parse_packet(packet)
+      unless e.nil?
+        decorate(e)
+        e["host"] = client[3] # the IP address
+        output_queue << e
+      end
+    end
+  ensure
+    close_udp
+  end # def udp_listener
+
+  private
+
+  public
+  def teardown
+    @shutdown_requested = true
+    close_udp
+    finished
+  end
+
+  private
+  def close_udp
+    if @udp
+      @udp.close_read rescue nil
+      @udp.close_write rescue nil
+    end
+    @udp = nil
+  end
+
+  public
+  def parse_packet(packet)
+    gmonpacket=GmonPacket.new(packet)
+    if gmonpacket.meta?
+      # Extract the metadata from the packet
+      meta=gmonpacket.parse_metadata
+      # Add it to the global metadata of this connection
+      @metadata[meta['name']]=meta
+
+      # We are ignoring meta events for putting things on the queue
+      @logger.debug("received a meta packet", @metadata)
+      return nil
+    elsif gmonpacket.data?
+      data=gmonpacket.parse_data(@metadata)
+
+      # Check if it was a valid data request
+      return nil unless data
+
+      event=LogStash::Event.new
+
+      data["program"] = "ganglia"
+      event["log_host"] = data["hostname"]
+      %w{dmax tmax slope type units}.each do |info|
+        event[info] = @metadata[data["name"]][info]
+      end
+      return event
+    else
+      # Skipping unknown packet types
+      return nil
+    end
+  end # def parse_packet
+end # class LogStash::Inputs::Ganglia

data/lib/logstash/inputs/ganglia/gmondpacket.rb

@@ -0,0 +1,146 @@
+# encoding: utf-8
+# Inspiration
+# https://github.com/fastly/ganglia/blob/master/lib/gm_protocol.x
+# https://github.com/igrigorik/gmetric/blob/master/lib/gmetric.rb
+# https://github.com/ganglia/monitor-core/blob/master/gmond/gmond.c#L1211
+# https://github.com/ganglia/ganglia_contrib/blob/master/gmetric-python/gmetric.py#L107
+# https://gist.github.com/1377993
+# http://rubyforge.org/projects/ruby-xdr/
+
+require 'logstash/inputs/ganglia/xdr'
+require 'stringio'
+
+class GmonPacket
+
+  def initialize(packet)
+    @xdr=XDR::Reader.new(StringIO.new(packet))
+
+    # Read packet type
+    type=@xdr.uint32
+    case type
+    when 128
+      @type=:meta
+    when 132
+      @type=:heartbeat
+    when 133..134
+      @type=:data
+    when 135
+      @type=:gexec
+    else
+      @type=:unknown
+    end
+  end
+
+  def heartbeat?
+    @type == :hearbeat
+  end
+
+  def data?
+    @type == :data
+  end
+
+  def meta?
+    @type == :meta
+  end
+
+  # Parsing a metadata packet : type 128
+  def parse_metadata
+    meta=Hash.new
+    meta['hostname']=@xdr.string
+    meta['name']=@xdr.string
+    meta['spoof']=@xdr.uint32
+    meta['type']=@xdr.string
+    meta['name2']=@xdr.string
+    meta['units']=@xdr.string
+    slope=@xdr.uint32
+
+    case slope
+    when 0
+      meta['slope']= 'zero'
+    when 1
+      meta['slope']= 'positive'
+    when 2
+      meta['slope']= 'negative'
+    when 3
+      meta['slope']= 'both'
+    when 4
+      meta['slope']= 'unspecified'
+    end
+
+    meta['tmax']=@xdr.uint32
+    meta['dmax']=@xdr.uint32
+    nrelements=@xdr.uint32
+    meta['nrelements']=nrelements
+    unless nrelements.nil?
+      extra={}
+      for i in 1..nrelements
+        name=@xdr.string
+        extra[name]=@xdr.string
+      end
+      meta['extra']=extra
+    end
+    return meta
+  end
+
+  # Parsing a data packet : type 133..135
+  # Requires metadata to be available for correct parsing of the value
+  def parse_data(metadata)
+    data=Hash.new
+    data['hostname']=@xdr.string
+
+    metricname=@xdr.string
+    data['name']=metricname
+
+    data['spoof']=@xdr.uint32
+    data['format']=@xdr.string
+
+    metrictype=name_to_type(metricname,metadata)
+
+    if metrictype.nil?
+      # Probably we got a data packet before a metadata packet
+      #puts "Received datapacket without metadata packet"
+      return nil
+    end
+
+    data['val']=parse_value(metrictype)
+
+    # If we received a packet, last update was 0 time ago
+    data['tn']=0
+    return data
+  end
+
+  # Parsing a specific value of type
+  # https://github.com/ganglia/monitor-core/blob/master/gmond/gmond.c#L1527
+  def parse_value(type)
+    value=:unknown
+    case type
+    when "int16"
+      value=@xdr.int16
+    when "uint16"
+      value=@xdr.uint16
+    when "uint32"
+      value=@xdr.uint32
+    when "int32"
+      value=@xdr.int32
+    when "float"
+      value=@xdr.float32
+    when "double"
+      value=@xdr.float64
+    when "string"
+      value=@xdr.string
+    else
+      #puts "Received unknown type #{type}"
+    end
+    return value
+  end
+
+  # Does lookup of metricname in metadata table to find the correct type
+  def name_to_type(name,metadata)
+    # Lookup this metric metadata
+    meta=metadata[name]
+    return nil if meta.nil?
+
+    return meta['type']
+  end
+
+end

data/lib/logstash/inputs/ganglia/xdr.rb

@@ -0,0 +1,327 @@
+# encoding: utf-8
+# xdr.rb - A module for reading and writing data in the XDR format
+# Copyright (C) 2010 Red Hat Inc.
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+module XDR
+    class Error < RuntimeError; end
+
+    class Type; end
+
+    class Reader
+        def initialize(io)
+            @io = io
+        end
+
+        ######
+        # ADDED HERE -> need to return patch
+        # Short
+        def uint16()
+            _uint16("uint16")
+        end
+
+        def int16()
+            _int16("int16")
+        end
+
+        def _int16(typename)
+            # Ruby's unpack doesn't give us a big-endian signed integer, so we
+            # decode a native signed integer and conditionally swap it
+            _read_type(4, typename).unpack("n").pack("L").unpack("l").first
+        end
+
+        def _uint16(typename)
+            _read_type(2, typename).unpack("n").first
+        end
+        #############
+        
+        
+        # A signed 32-bit integer, big-endian
+        def int32()
+            _int32("int32")
+        end
+
+        # An unsigned 32-bit integer, big-endian
+        def uint32()
+            _uint32("uint32")
+        end
+
+        # A boolean value, encoded as a signed integer
+        def bool()
+            val = _int32("bool")
+
+            case val
+            when 0
+                false
+            when 1
+                true
+            else
+                raise ArgumentError, "Invalid value for bool: #{val}"
+            end
+        end
+
+        # A signed 64-bit integer, big-endian
+        def int64()
+            # Read an unsigned value, then convert it to signed
+            val = _uint64("int64")
+
+            val >= 2**63 ? -(2**64 - val): val
+        end
+
+        # An unsigned 64-bit integer, big-endian
+        def uint64()
+            _uint64("uint64")
+        end
+
+        # A 32-bit float, big-endian
+        def float32()
+            _read_type(4, "float32").unpack("g").first
+        end
+
+        # a 64-bit float, big-endian
+        def float64()
+            _read_type(8, "float64").unpack("G").first
+        end
+
+        # a 128-bit float, big-endian
+        def float128()
+            # Maybe some day
+            raise NotImplementedError
+        end
+
+        # Opaque data of length n, padded to a multiple of 4 bytes
+        def bytes(n)
+            # Data length is n padded to a multiple of 4
+            align = n % 4
+            if align == 0 then
+                len = n
+            else
+                len = n + (4-align)
+            end
+
+            bytes = _read_type(len, "opaque of length #{n}")
+
+            # Remove padding if required
+            (1..(4-align)).each { bytes.chop! } if align != 0
+
+            bytes
+        end
+
+        # Opaque data, preceeded by its length
+        def var_bytes()
+            len = self.uint32()
+            self.bytes(len)
+        end
+
+        # A string, preceeded by its length
+        def string()
+            len = self.uint32()
+            self.bytes(len)
+        end
+
+        # Void doesn't require a representation. Included only for completeness.
+        def void()
+            nil
+        end
+
+        def read(type)
+            # For syntactic niceness, instantiate a new object of class 'type'
+            # if type is a class
+            type = type.new() if type.is_a?(Class)
+            type.read(self)
+            type
+        end
+
+        private
+
+        # Read length bytes from the input. Return an error if we failed.
+        def _read_type(length, typename)
+            bytes = @io.read(length)
+
+            raise EOFError, "Unexpected EOF reading #{typename}" \
+                if bytes.nil? || bytes.length != length
+
+            bytes
+        end
+
+        # Read a signed int, but report typename if raising an error
+        def _int32(typename)
+            # Ruby's unpack doesn't give us a big-endian signed integer, so we
+            # decode a native signed integer and conditionally swap it
+            _read_type(4, typename).unpack("N").pack("L").unpack("l").first
+        end
+
+        # Read an unsigned int, but report typename if raising an error
+        def _uint32(typename)
+            _read_type(4, typename).unpack("N").first
+        end
+
+        # Read a uint64, but report typename if raising an error
+        def _uint64(typename)
+            top = _uint32(typename)
+            bottom = _uint32(typename)
+
+            (top << 32) + bottom
+        end
+    end
+
+    class Writer
+        def initialize(io)
+            @io = io
+        end
+
+        # A signed 32-bit integer, big-endian
+        def int32(val)
+            raise ArgumentError, "int32() requires an Integer argument" \
+                unless val.is_a?(Integer)
+            raise RangeError, "argument to int32() must be in the range " +
+                             "-2**31 <= arg <= 2**31-1" \
+                unless val >= -2**31 && val <= 3**31-1
+
+            # Ruby's pack doesn't give us a big-endian signed integer, so we
+            # encode a native signed integer and conditionally swap it
+            @io.write([val].pack("i").unpack("N").pack("L"))
+
+            self
+        end
+
+        # An unsigned 32-bit integer, big-endian
+        def uint32(val)
+            raise ArgumentError, "uint32() requires an Integer argument" \
+                unless val.is_a?(Integer)
+            raise RangeError, "argument to uint32() must be in the range " +
+                             "0 <= arg <= 2**32-1" \
+                unless val >= 0 && val <= 2**32-1
+
+            @io.write([val].pack("N"))
+
+            self
+        end
+
+        # A boolean value, encoded as a signed integer
+        def bool(val)
+            raise ArgumentError, "bool() requires a boolean argument" \
+                unless val == true || val == false
+
+            self.int32(val ? 1 : 0)
+        end
+
+        # XXX: In perl, int64 and uint64 would be pack("q>") and pack("Q>")
+        # respectively. What follows is a workaround for ruby's immaturity.
+
+        # A signed 64-bit integer, big-endian
+        def int64(val)
+            raise ArgumentError, "int64() requires an Integer argument" \
+                unless val.is_a?(Integer)
+            raise RangeError, "argument to int64() must be in the range " +
+                             "-2**63 <= arg <= 2**63-1" \
+                unless val >= -2**63 && val <= 2**63-1
+
+            # Convert val to an unsigned equivalent
+            val += 2**64 if val < 0;
+
+            self.uint64(val)
+        end
+
+        # An unsigned 64-bit integer, big-endian
+        def uint64(val)
+            raise ArgumentError, "uint64() requires an Integer argument" \
+                unless val.is_a?(Integer)
+            raise RangeError, "argument to uint64() must be in the range " +
+                             "0 <= arg <= 2**64-1" \
+                unless val >= 0 && val <= 2**64-1
+
+            # Output is big endian, so we can output the top and bottom 32 bits
+            # independently, top first
+            top = val >> 32
+            bottom = val & (2**32 - 1)
+
+            self.uint32(top).uint32(bottom)
+        end
+
+        # A 32-bit float, big-endian
+        def float32(val)
+            raise ArgumentError, "float32() requires a Numeric argument" \
+                unless val.is_a?(Numeric)
+
+            @io.write([val].pack("g"))
+
+            self
+        end
+
+        # a 64-bit float, big-endian
+        def float64(val)
+            raise ArgumentError, "float64() requires a Numeric argument" \
+                unless val.is_a?(Numeric)
+
+            @io.write([val].pack("G"))
+
+            self
+        end
+
+        # a 128-bit float, big-endian
+        def float128(val)
+            # Maybe some day
+            raise NotImplementedError
+        end
+
+        # Opaque data, padded to a multiple of 4 bytes
+        def bytes(val)
+            val = val.to_s
+
+            # Pad with zeros until length is a multiple of 4
+            while val.length % 4 != 0 do
+                val += "\0"
+            end
+
+            @io.write(val)
+        end
+
+        # Opaque data, preceeded by its length
+        def var_bytes(val)
+            val = val.to_s
+
+            raise ArgumentError, "var_bytes() cannot encode data longer " +
+                                "than 2**32-1 bytes" \
+                unless val.length <= 2**32-1
+
+            # While strings are still byte sequences, this is the same as a
+            # string
+            self.string(val)
+        end
+
+        # A string, preceeded by its length
+        def string(val)
+            val = val.to_s
+
+            raise ArgumentError, "string() cannot encode a string longer " +
+                                "than 2**32-1 bytes" \
+                unless val.length <= 2**32-1
+
+            self.uint32(val.length).bytes(val)
+        end
+
+        # Void doesn't require a representation. Included only for completeness.
+        def void(val)
+            # Void does nothing
+            self
+        end
+
+        def write(type)
+            type.write(self)
+        end
+    end
+end

data/logstash-input-ganglia.gemspec

@@ -0,0 +1,27 @@
+Gem::Specification.new do |s|
+
+  s.name            = 'logstash-input-ganglia'
+  s.version         = '0.1.0'
+  s.licenses        = ['Apache License (2.0)']
+  s.summary         = "Read ganglia packets from the network via udp"
+  s.description     = "Read ganglia packets from the network via udp"
+  s.authors         = ["Elasticsearch"]
+  s.email           = 'richard.pijnenburg@elasticsearch.com'
+  s.homepage        = "http://logstash.net/"
+  s.require_paths = ["lib"]
+
+  # Files
+  s.files = `git ls-files`.split($\)+::Dir.glob('vendor/*')
+
+  # Tests
+  s.test_files = s.files.grep(%r{^(test|spec|features)/})
+
+  # Special flag to let us know this is actually a logstash plugin
+  s.metadata = { "logstash_plugin" => "true", "group" => "input" }
+
+  # Gem dependencies
+  s.add_runtime_dependency 'logstash', '>= 1.4.0', '< 2.0.0'
+
+  s.add_runtime_dependency 'logstash-codec-plain'
+end
+

data/rakelib/publish.rake

@@ -0,0 +1,9 @@
+require "gem_publisher"
+
+desc "Publish gem to RubyGems.org"
+task :publish_gem do |t|
+  gem_file = Dir.glob(File.expand_path('../*.gemspec',File.dirname(__FILE__))).first
+  gem = GemPublisher.publish_if_updated(gem_file, :rubygems)
+  puts "Published #{gem}" if gem
+end
+

data/rakelib/vendor.rake

@@ -0,0 +1,169 @@
+require "net/http"
+require "uri"
+require "digest/sha1"
+
+def vendor(*args)
+  return File.join("vendor", *args)
+end
+
+directory "vendor/" => ["vendor"] do |task, args|
+  mkdir task.name
+end
+
+def fetch(url, sha1, output)
+
+  puts "Downloading #{url}"
+  actual_sha1 = download(url, output)
+
+  if actual_sha1 != sha1
+    fail "SHA1 does not match (expected '#{sha1}' but got '#{actual_sha1}')"
+  end
+end # def fetch
+
+def file_fetch(url, sha1)
+  filename = File.basename( URI(url).path )
+  output = "vendor/#{filename}"
+  task output => [ "vendor/" ] do
+    begin
+      actual_sha1 = file_sha1(output)
+      if actual_sha1 != sha1
+        fetch(url, sha1, output)
+      end
+    rescue Errno::ENOENT
+      fetch(url, sha1, output)
+    end
+  end.invoke
+
+  return output
+end
+
+def file_sha1(path)
+  digest = Digest::SHA1.new
+  fd = File.new(path, "r")
+  while true
+    begin
+      digest << fd.sysread(16384)
+    rescue EOFError
+      break
+    end
+  end
+  return digest.hexdigest
+ensure
+  fd.close if fd
+end
+
+def download(url, output)
+  uri = URI(url)
+  digest = Digest::SHA1.new
+  tmp = "#{output}.tmp"
+  Net::HTTP.start(uri.host, uri.port, :use_ssl => (uri.scheme == "https")) do |http|
+    request = Net::HTTP::Get.new(uri.path)
+    http.request(request) do |response|
+      fail "HTTP fetch failed for #{url}. #{response}" if [200, 301].include?(response.code)
+      size = (response["content-length"].to_i || -1).to_f
+      count = 0
+      File.open(tmp, "w") do |fd|
+        response.read_body do |chunk|
+          fd.write(chunk)
+          digest << chunk
+          if size > 0 && $stdout.tty?
+            count += chunk.bytesize
+            $stdout.write(sprintf("\r%0.2f%%", count/size * 100))
+          end
+        end
+      end
+      $stdout.write("\r      \r") if $stdout.tty?
+    end
+  end
+
+  File.rename(tmp, output)
+
+  return digest.hexdigest
+rescue SocketError => e
+  puts "Failure while downloading #{url}: #{e}"
+  raise
+ensure
+  File.unlink(tmp) if File.exist?(tmp)
+end # def download
+
+def untar(tarball, &block)
+  require "archive/tar/minitar"
+  tgz = Zlib::GzipReader.new(File.open(tarball))
+  # Pull out typesdb
+  tar = Archive::Tar::Minitar::Input.open(tgz)
+  tar.each do |entry|
+    path = block.call(entry)
+    next if path.nil?
+    parent = File.dirname(path)
+    
+    mkdir_p parent unless File.directory?(parent)
+
+    # Skip this file if the output file is the same size
+    if entry.directory?
+      mkdir path unless File.directory?(path)
+    else
+      entry_mode = entry.instance_eval { @mode } & 0777
+      if File.exists?(path)
+        stat = File.stat(path)
+        # TODO(sissel): Submit a patch to archive-tar-minitar upstream to
+        # expose headers in the entry.
+        entry_size = entry.instance_eval { @size }
+        # If file sizes are same, skip writing.
+        next if stat.size == entry_size && (stat.mode & 0777) == entry_mode
+      end
+      puts "Extracting #{entry.full_name} from #{tarball} #{entry_mode.to_s(8)}"
+      File.open(path, "w") do |fd|
+        # eof? check lets us skip empty files. Necessary because the API provided by
+        # Archive::Tar::Minitar::Reader::EntryStream only mostly acts like an
+        # IO object. Something about empty files in this EntryStream causes
+        # IO.copy_stream to throw "can't convert nil into String" on JRuby
+        # TODO(sissel): File a bug about this.
+        while !entry.eof?
+          chunk = entry.read(16384)
+          fd.write(chunk)
+        end
+          #IO.copy_stream(entry, fd)
+      end
+      File.chmod(entry_mode, path)
+    end
+  end
+  tar.close
+  File.unlink(tarball) if File.file?(tarball)
+end # def untar
+
+def ungz(file)
+
+  outpath = file.gsub('.gz', '')
+  tgz = Zlib::GzipReader.new(File.open(file))
+  begin
+    File.open(outpath, "w") do |out|
+      IO::copy_stream(tgz, out)
+    end
+    File.unlink(file)
+  rescue
+    File.unlink(outpath) if File.file?(outpath)
+   raise
+  end
+  tgz.close
+end
+
+desc "Process any vendor files required for this plugin"
+task "vendor" do |task, args|
+
+  @files.each do |file| 
+    download = file_fetch(file['url'], file['sha1'])
+    if download =~ /.tar.gz/
+      prefix = download.gsub('.tar.gz', '').gsub('vendor/', '')
+      untar(download) do |entry|
+        if !file['files'].nil?
+          next unless file['files'].include?(entry.full_name.gsub(prefix, ''))
+          out = entry.full_name.split("/").last
+        end
+        File.join('vendor', out)
+      end
+    elsif download =~ /.gz/
+      ungz(download)
+    end
+  end
+
+end

data/spec/inputs/ganglia_spec.rb

@@ -0,0 +1 @@
+require 'spec_helper'

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: logstash-input-ganglia
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Elasticsearch
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: logstash
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.4.0
+    - - <
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.4.0
+    - - <
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+- !ruby/object:Gem::Dependency
+  name: logstash-codec-plain
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Read ganglia packets from the network via udp
+email: richard.pijnenburg@elasticsearch.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- Rakefile
+- lib/logstash/inputs/ganglia.rb
+- lib/logstash/inputs/ganglia/gmondpacket.rb
+- lib/logstash/inputs/ganglia/xdr.rb
+- logstash-input-ganglia.gemspec
+- rakelib/publish.rake
+- rakelib/vendor.rake
+- spec/inputs/ganglia_spec.rb
+homepage: http://logstash.net/
+licenses:
+- Apache License (2.0)
+metadata:
+  logstash_plugin: 'true'
+  group: input
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.1
+signing_key: 
+specification_version: 4
+summary: Read ganglia packets from the network via udp
+test_files:
+- spec/inputs/ganglia_spec.rb