panteras_api 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 864bf7c91dedd75b7472623ef2b101983e0b6d47
+  data.tar.gz: edabdfc6739a10e554fdc9af1b7f5bda129ea1ce
+SHA512:
+  metadata.gz: 1d84d1d010ce1032e30262e40c5216415a756b1a142a005c18c552aea2285c6ada1f4b39de68e8bf18b4013eae3b237c10cca919580503c0495938f236af1f6c
+  data.tar.gz: 1af38e7b35769ed315f12283d748e19c14b1fb865d4280803c7738f032eebfe4f6d096e8cf4815000b0c7306e524caa522d1a925140e33d5325270142644ce7d

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.project
+.buildpath

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.2.0

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in panteras_api.gemspec
+gemspec

data/README.md

@@ -0,0 +1,30 @@
+# PanterasApi
+
+This is a program that checks services consistencies in a mesos/marathon/consul/docker PaaS infrastructure.
+
+It is intended for use together with the [Panteras](https://github.com/eBayClassifiedsGroup/PanteraS) project.
+
+**It will not work on other systems without tweaking the main program.**
+
+## Installation
+
+    $ gem install panteras_api
+
+## Usage
+
+	Usage: bin/panteras_api [options]
+    -m MESOS_MASTER_HOSTNAME,        Default: localhost
+        --mesos-master-hostname
+    -p MESOS_MASTER_PORT,            Default: 5050
+        --mesos-master-port
+    -d, --debug                      Default: false
+    -f FULLY_QUALIFIED_HOSTNAME,     Default: autodiscovery via gethostbyname
+        --fqdn
+
+## Notes
+
+* Exits with error code 1 when problems seen
+* Exits with code 0 when everything is OK
+* outputs a short text summary
+* intended for use as a nagios-style check
+* this script should be run on all mesos slaves (docker hosts)

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/extra/mesos_consul_consistency_check

@@ -0,0 +1,181 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'panteras_api'
+require 'json'
+
+config_default = {
+  :mesos_master_hostname => 'localhost',
+  :mesos_master_port => 5050,
+  :debug => false,
+  :fqdn => nil,
+  :error_exit_code => 1
+}
+
+options = {}
+bad_news = []
+good_news = []
+
+OptionParser.new("Usage: #{$0} [options]")  do |opts|
+  opts.release =  PanterasApi::VERSION
+  
+  opts.on("-m", "--mesos-master-hostname MESOS_MASTER_HOSTNAME", "Default: #{config_default[:mesos_master_hostname]}") do |m|
+    options[:mesos_master_hostname] = m
+  end
+  
+  opts.on("-p", "--mesos-master-port MESOS_MASTER_PORT", "Default: #{config_default[:mesos_master_port]}") do |p|
+    options[:mesos_master_port] = p
+  end
+  
+  opts.on("-d", "--debug", "Default: #{config_default[:debug]}") do |d|
+    options[:debug] = d
+  end
+  
+  opts.on("-c", "--critical", "Exit with Nagios CRITICAL (code 2). Default: WARNING (#{config_default[:error_exit_code]})") do |c|
+    options[:error_exit_code] = 2
+  end
+  
+  opts.on("-f", "--fqdn FULLY_QUALIFIED_HOSTNAME", "Default: autodiscovery via gethostbyname") do |f|
+    options[:fqdn] = f
+  end
+  
+  
+end.parse!
+
+config_default[:fqdn] = Utils.fully_qualified_hostname if options[:fqdn].nil?
+config = config_default.merge!(options)
+
+### MESOS
+
+my_fqdn = config[:fqdn]
+
+puts "#" * 75 if config[:debug]
+puts "* My hostname: #{my_fqdn}" if config[:debug]
+
+begin
+  puts "* Connecting to Mesos host: #{config[:mesos_master_hostname]}:#{config[:mesos_master_port]}" if config[:debug]
+  mesos = MesosCluster.new(config[:mesos_master_hostname], config[:mesos_master_port])
+rescue SocketError, Errno::ECONNREFUSED => e
+  abort("Problem connecting to mesos host #{config[:mesos_master_hostname]}:#{config[:mesos_master_port]}: #{e.message}")
+end
+
+abort("No running mesos tasks seen on mesos master #{config[:mesos_master_hostname]}:#{config[:mesos_master_port]}") if mesos.tasks.size == 0
+
+puts "#" * 75 if config[:debug]
+puts "* Mesos tasks ids running this cluster (all slaves):" if config[:debug]
+puts mesos.tasks if config[:debug]
+
+
+puts "#" * 75 if config[:debug]
+puts "* Mesos tasks ids for tasks running on #{my_fqdn}:" if config[:debug]
+mesos_tasks = mesos.my_tasks_ids(my_fqdn).flatten
+puts mesos_tasks if config[:debug]
+  
+good_news << "#{mesos_tasks.size} mesos tasks running." if ! mesos_tasks.empty?
+  
+
+### MARATHON
+marathon = MarathonEndpoint.new(mesos.master_hostname)
+
+puts "#" * 75 if config[:debug]
+puts "* Marathon tasks on #{my_fqdn}:" if config[:debug]
+marathon_tasks = marathon.my_task_ids(my_fqdn)
+puts marathon_tasks if config[:debug]
+
+good_news << "#{marathon_tasks.size} marathon tasks running."
+
+## compare mesos tasks (source of truth) with tasks seen in marathon
+only_in_mesos = mesos_tasks - marathon_tasks
+
+## compare marathon tasks with tasks seen in marathon
+only_in_marathon = marathon_tasks - mesos_tasks
+
+if ! only_in_mesos.empty?
+  bad_news << "mesos tasks not seen in marathon: #{only_in_mesos.join(',')}"
+end
+
+if ! only_in_marathon.empty?
+  bad_news << "marathon tasks not seen in mesos: #{only_in_marathon.join(',')}"
+end
+
+### CONSUL
+consul = ConsulCluster.new(mesos.master_hostname)
+### TODO: test with paas-formatted service names
+puts "#" * 75 if config[:debug]
+puts "* Consul services for #{my_fqdn}:" if config[:debug]
+consul_services = consul.my_service_ids
+puts consul.my_services.join("\n") if config[:debug]
+
+good_news << "#{consul.my_services.size} consul services running."
+
+### set these environment variables here or in shell for testing a remote docker (ie, boot2docker)
+#ENV['DOCKER_HOST']='tcp://192.168.59.103:2376'
+#ENV['DOCKER_CERT_PATH']='/Users/jcolby/.boot2docker/certs/boot2docker-vm'
+#ENV['DOCKER_TLS_VERIFY']='1'
+
+### Compare mesos vs docker tasks
+
+docker_inspect = DockerHost.inspect
+docker_tasks = docker_inspect.collect { |d| d[:mesos_task_id] }.compact.reject { |i| i.empty? }
+docker_mesos_ids = docker_inspect.collect { |d| d[:name] }.compact.reject { |i| i.empty? }
+
+puts "#" * 75 if config[:debug]
+puts "* Docker tasks on #{my_fqdn}:" if config[:debug]
+puts docker_inspect if config[:debug]
+
+mesos_not_docker = mesos_tasks - docker_tasks
+if ! mesos_not_docker.empty?
+  bad_news << "mesos tasks not running in docker: #{mesos_not_docker.join(',')}"
+end
+
+docker_not_mesos = docker_tasks - mesos_tasks
+if ! docker_not_mesos.empty?
+  bad_news << "docker tasks not seen in mesos: #{docker_not_mesos.join(',')}"
+end
+
+good_news << "#{docker_tasks.size} docker tasks running"
+
+### Compare consul-registered tasks vs docker tasks
+docker_mesos_ids_no_panteras = docker_inspect.reject { |p| p[:name] =~ /panteras/ }.collect { |d| d[:name] }.compact.reject { |i| i.empty? }
+consul_not_docker = consul_services - docker_mesos_ids_no_panteras
+docker_not_consul = docker_mesos_ids_no_panteras - consul_services
+
+if ! consul_not_docker.empty?
+  bad_news << "consul tasks not seen in docker: #{consul_not_docker.join(',')}"
+end
+
+if ! docker_not_consul.empty?
+  bad_news << "docker tasks not seen in consul: #{docker_not_consul.join(',')}"
+end
+
+if ! bad_news.empty?
+  puts "problems on #{my_fqdn}: #{bad_news.join(' ')}"
+  exit config[:error_exit_code]  
+end
+
+puts good_news.join(' ')
+
+__END__
+
+##### MAPPING ###
+CHECKS:
+ mesos vs marathon
+ mesos vs docker
+ docker vs consul 
+
+consul (api):
+Slave Host, mesos-name (ServiceID) "paasslave46-2:mesos-c71da994-a35b-4dde-9970-d175c04da735:8080"
+
+docker inspect:
+container-id (Id)  "7caf2037e7870ca4b0c5574a9f5a2415e43999fc83a9269c0360c34007957b2b"
+mesos-name (Name)  "mesos-c71da994-a35b-4dde-9970-d175c04da735"
+mesos-task-id (ENV MESOS_TASK_ID)   "vehicle-catalog-service.49383b0b-26eb-11e5-8a45-56847afe9799"
+
+marathon API:
+mesos-task-id (TaskId): "vehicle-catalog-service.49383b0b-26eb-11e5-8a45-56847afe9799"
+
+
+mesos API:
+"id": "vehicle-catalog-service.49383b0b-26eb-11e5-8a45-56847afe9799"
+
+

data/extra/mesos_consul_consistency_check_nagios_wrapper

@@ -0,0 +1,124 @@
+#!/usr/bin/env ruby
+
+require 'open3'
+require 'socket'
+require 'optparse'
+
+$VERSION = '1.0.0'
+$SEND_NSCA='/usr/sbin/send_nsca'
+$SCRIPT='/usr/local/bin/panteras_api'
+my_datacenter=Socket.ip_address_list.find { |ai| ai.ipv4? && !ai.ipv4_loopback? }.ip_address.split('.')[1]
+$MESOS_MASTER="paasmaster#{my_datacenter.strip}-1.mobile.rz"
+$NAGIOS_SERVICE='paas_consistency_check'
+
+# default nagios host
+defaults = { :nsca_host => 'monitor.mobile.rz', :debug => false, :error_code => 1 }
+options = {}
+  
+OptionParser.new("Options: #{$0} -n NAGIOS_HOST [options]") do |opts|
+ 
+ opts.release =  $VERSION
+ 
+ opts.on("-n","--nsca-host NAGIOS_HOST","") do |n|
+   options[:nsca_host] = n
+ end
+ 
+  opts.on("-d","--debug","") do |d|
+    options[:debug] = true
+  end
+
+  opts.on("-c", "--critical", "Exit with CRITICAL when problems seen. Default is WARNING") do |c|
+    options[:error_code] = 2 
+  end
+ 
+end.parse!
+
+config = defaults.merge!(options)
+
+
+$DEBUG = config[:debug]
+my_hostname = Socket.gethostname.strip
+my_fqdn = Socket.gethostbyname(my_hostname).first
+nsca_host = config[:nsca_host]
+output = []
+error = []
+puts "DEBUG MODE ON" if $DEBUG
+puts "NSCA host set to: #{nsca_host}" if $DEBUG
+
+def send_ncsa(nagios_host, host, result, code)
+  output = []
+  error = []
+  command="#{$SEND_NSCA} -c /etc/send_nsca.cfg -H #{nagios_host}"
+  puts "Running command: #{command}" if $DEBUG
+  Open3.popen3(command) do |stdin, stdout, stderr, wait_thr|
+  
+  result_line = "#{host}\t#{$NAGIOS_SERVICE}\t#{code}\t#{result}"
+  puts "Sending result to #{nagios_host}: #{result_line}" if $DEBUG
+  stdin.puts result_line
+  stdin.close
+  
+  exit_status = wait_thr.value
+  
+      unless exit_status.success?
+          $stderr.puts stderr.readlines
+          raise StandardError, "Command '#{command}' returned status #{exit_status.exitstatus}"          
+        end
+        
+        while line = stderr.gets
+          if line.strip.length > 0
+            puts "Error (send_ncsa): #{line}" if $DEBUG
+            error << line.strip
+          end
+        end
+        
+        while line = stdout.gets
+         if line.strip.length > 0 
+           puts "Output (send ncsa): #{line}" if $DEBUG
+           output << line.strip
+         end
+        end  
+
+  end
+  
+  puts output.join if ( ! output.empty? && $DEBUG ) 
+  puts error.join if ( ! error.empty? && $DEBUG )
+
+end
+
+command = "#{$SCRIPT} -m #{$MESOS_MASTER}"
+puts "Running command: #{command}" if $DEBUG
+
+
+Open3.popen3(command) do |stdin, stdout, stderr, wait_thr|
+
+	exit_status = wait_thr.value
+	    unless exit_status.success?
+          send_ncsa(nsca_host, my_hostname, stderr.readlines, config[:error_code])
+          raise StandardError, "Command '#{command}' returned status #{exit_status.exitstatus}"          
+        end
+        
+        while line = stderr.gets          
+          if line.strip.length > 0
+            puts "Error: #{line}" if $DEBUG
+            error << line.strip
+          end
+        end
+        
+        while line = stdout.gets
+         if line.strip.length > 0 
+           puts "Output: #{line}" if $DEBUG        
+           output << line.strip
+         end
+        end  
+        
+        if ! error.empty?
+          error_msg = error.join
+          puts "#{my_hostname}: #{error_msg} exit_code #{config[:error_code]}"
+          send_ncsa(nsca_host, my_hostname, error.join, config[:error_code])
+        else
+          output_msg = output.join
+          puts "#{my_hostname}: #{output_msg} exit_code #{config[:error_code]}"
+          send_ncsa(nsca_host, my_hostname, output.join, 0)
+        end
+
+end

data/lib/panteras_api.rb

@@ -0,0 +1,11 @@
+require "panteras_api/version"
+require "panteras_api/utils"
+require "panteras_api/http_utils"
+require "panteras_api/mesos_cluster"
+require "panteras_api/marathon_endpoint"
+require "panteras_api/consul_cluster"
+require "panteras_api/docker_host"
+
+module PanterasApi
+  # Your code goes here...
+end

data/lib/panteras_api/consul_cluster.rb

@@ -0,0 +1,45 @@
+class ConsulCluster
+  include HTTPUtils
+  include Utils
+
+  def initialize(host,port=8500)
+    @host = host
+    @port = port
+    @datacenters = datacenters
+    @dc = ""
+    @hostname = Utils.hostname
+  end
+  
+  def dc=(datacenter)
+    raise ArgumentError, "#{datacenter} is not a valid datacenter" unless (@datacenters.include? datacenter)
+    @dc = datacenter
+  end
+  
+  def datacenters
+    to_j(get_response_with_redirect(@host, '/v1/catalog/datacenters', @port))
+  end
+    
+  def services
+    service_names.collect { |s| service s.to_s }
+  end
+  
+  def service_names
+    services = to_j(get_response_with_redirect(@host, '/v1/catalog/services?dc=' + @dc, @port)).keys
+    # exclude the consul service itself
+    services.reject { |s| s.to_s == "consul" }
+  end
+  
+  def my_services(hostname=@hostname)
+    raise ArgumentError, "missing hostname argument", caller if hostname.nil?
+    services.collect { |s| s.select { |i| i[:Node] =~ /^#{hostname}$/ } }.flatten
+  end
+  
+  def my_service_ids
+     my_services.collect { |s| s[:ServiceID].split(/:/)[1] }
+  end
+  
+  def service(service)
+    to_j(get_response_with_redirect(@host, '/v1/catalog/service/' + service + '?dc=' + @dc, @port))
+  end
+  
+end

data/lib/panteras_api/docker_host.rb

@@ -0,0 +1,77 @@
+require 'open3'
+
+class DockerHost
+  extend HTTPUtils
+  
+  def self.ps
+    self.command("docker ps")[:output]
+  end
+  
+  def self.running_containers
+    output = self.command("docker ps")[:output]
+    raise MesosConsulCommandError, "Command 'docker ps' did not return an array of strings" if (output.class != Array || output.length == 0)
+    
+    result = output.map.with_index do |line, i|
+      next if i == 0 
+      container_id, image, *center, name = line.split
+      { container_id:  container_id, name: name, image: image }       
+    end
+    
+    return result.compact
+  end
+  
+  def self.inspect(*keys)
+    containers = self.running_containers
+    containers.map do |c|
+      inspect = self.command("docker inspect #{c[:container_id]}")[:output]
+      h = to_j(inspect.join).first    
+      task_id = h[:Config][:Env].select { |env| env =~ /MESOS_TASK_ID=/ }.first
+      mesos_task_id = task_id.nil? ? '' : task_id.split(/=/)[1] 
+      { id: h[:Id], image: h[:Image], name: h[:Name][1..-1], mesos_task_id: mesos_task_id }
+    end
+  end
+  
+  def self.inspect_partial
+    self.inspect
+  end
+  
+  private
+  
+  class MesosConsulCommandError < StandardError ; end
+  
+  def self.command(command)
+    output = []
+    error = []
+    begin
+      Open3.popen3(command) do |stdin, stdout, stderr, wait_thr|
+        
+        exit_status = wait_thr.value
+        
+        unless exit_status.success?
+          $stderr.puts stderr.readlines
+          raise MesosConsulCommandError, "Command '#{command}' returned status #{exit_status.exitstatus}"          
+        end
+        
+        while line = stderr.gets
+          $stderr.puts line
+          if line.strip.length > 0
+            error << line.strip
+          end
+        end
+        
+        while line = stdout.gets
+         if line.strip.length > 0          
+           output << line.strip
+         end
+        end     
+      
+      end
+      
+    rescue Errno::ENOENT => e
+      raise MesosConsulCommandError, "Error while running command #{command}: #{e.message}"
+    end
+      
+    return { :output => output, :error => error}
+       
+  end
+end

data/lib/panteras_api/http_utils.rb

@@ -0,0 +1,40 @@
+require 'json'
+require 'net/http'
+require 'uri'
+
+module HTTPUtils
+
+  def get_response_with_redirect(*args)
+     response = Net::HTTP.get_response(*args)
+     if response.is_a?(Net::HTTPRedirection)
+       begin
+       redirect_uri = URI.parse(response.header['location'])
+       return redirect_uri
+       rescue SocketError => e
+         raise e, "Error connecting to #{redirect_uri}: #{e.message}"
+       end
+     end     
+     response
+  end
+  
+  def to_j(response)
+    if response.is_a? Net::HTTPResponse
+      JSON.parse(response.body, :symbolize_names => true)
+    elsif response.is_a? String
+      JSON.parse(response, :symbolize_names => true)
+    end 
+  end
+  
+  def valid_url(url)
+    if (url =~ /\A#{URI::regexp}\z/)
+      return true
+    end
+    return false
+  end
+  
+  def construct_uri(url)
+    raise Error::BadURLError unless (valid_url(url))
+    return URI.parse(url)
+  end
+  
+end

data/lib/panteras_api/marathon_endpoint.rb

@@ -0,0 +1,40 @@
+class MarathonEndpoint
+  include HTTPUtils
+  include Utils
+
+  def initialize(host, port=8080)
+    @host = host
+    @port = port
+  end
+  
+  def app(app_name)
+    raise ArgumentError, "Argument be a String" unless (app_name.class == String )
+    to_j(get_response_with_redirect(@host, '/v2/apps/' + app_name, @port))[:app]
+  end
+  
+  def all_apps
+    to_j(get_response_with_redirect(@host, '/v2/apps/', @port))[:apps]
+  end
+  
+  def app_names
+    all_apps.collect { |a| a[:id][1..-1] }
+  end
+  
+  def tasks_ids(app_name)
+    app(app_name)[:tasks].collect { |t| t[:id] }
+  end
+  
+  def my_tasks(hostname)
+    raise ArgumentError, "missing hostname argument", caller if hostname.nil?
+    app_names.collect { |n| app(n)[:tasks].select { |t| t[:host] =~ /^#{hostname}$/ }  }
+  end
+  
+  def my_task_ids(hostname)
+    my_tasks(hostname).collect { |t| t.collect { |a| a[:id] } }.flatten
+end
+  
+  def task_ids
+    app_names.collect { |a| tasks_ids(a) }
+  end
+  
+end

data/lib/panteras_api/mesos_cluster.rb

@@ -0,0 +1,80 @@
+#!/usr/bin/env ruby
+
+require 'uri'
+require 'json'
+
+class MesosCluster
+  include HTTPUtils
+  include Utils
+  
+  attr_reader :state
+  
+  def initialize(host, port=5050)
+    @host = host
+    @port = port
+    @master_info = "/master/redirect"
+    @state_info = "/state.json"
+    @state = parse_state
+  end
+
+  def parse_state
+    redirect_response = get_response_with_redirect(@host, @master_info, @port)
+    
+    if redirect_response.is_a?(URI::HTTP)
+      if ! valid_url(redirect_response.to_s)
+        raise StandardError, "Response from http://#{@host}:#{@port}#{@master_info} is not a valid url: #{redirect_response.to_s}"
+      end      
+      return to_j(get_response_with_redirect(URI.join(redirect_response.to_s, @state_info)))
+    end
+  
+  end
+  
+  def master_hostname
+    state[:hostname]    
+  end
+  
+  def master_id
+    state[:id]
+  end
+  
+  def frameworks
+    state[:frameworks]
+  end
+  
+  def tasks_completed
+    state[:frameworks].collect { |f| f[:completed_tasks].collect { |t| t  } }   
+  end
+  
+  def tasks
+    results = frameworks.collect { |f| f[:tasks].collect { |t| t[:slave_hostname] = slave_hostname_by_id(t[:slave_id]) ; t } }
+    results.reject { |r| r.nil? or r.length == 0 }.first
+  end
+  
+  def task_ids
+    tasks.collect { |t| t[:id] }
+  end
+  
+  def my_tasks_ids(hostname)
+   raise ArgumentError, "missing hostname argument", caller if hostname.nil?
+   tasks.select { |t| t[:slave_hostname] =~ /^#{hostname}$/ }.collect { |t| t[:id] }
+  end
+  
+  def resources
+    state[:frameworks].collect { |f| f[:used_resources] }
+  end
+  
+  def slave_hostname_by_id(id)
+    slaves.select { |s| s[:id] == id }.first[:hostname]
+  end
+  
+  def slaves
+    state[:slaves].collect do |s|
+      s.select { |k,v|  [:hostname, :id].include?(k)}
+    end
+  end
+  
+  def to_s
+    JSON.pretty_generate @state
+  end
+  
+end

data/lib/panteras_api/utils.rb

@@ -0,0 +1,17 @@
+require 'socket'
+
+module Utils
+  def self.hostname
+    Socket.gethostname.strip
+  end
+  
+  def self.fully_qualified_hostname
+    begin
+      Socket.gethostbyname(Socket.gethostname.strip).first
+    rescue SocketError => e
+      raise StandardError, "Could not get fully qualified domain name using gethostbyname."
+    end
+  end
+  
+  
+end

data/lib/panteras_api/version.rb

@@ -0,0 +1,3 @@
+module PanterasApi
+  VERSION = "0.0.1"
+end

data/panteras_api.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'panteras_api/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "panteras_api"
+  spec.version       = PanterasApi::VERSION
+  spec.authors       = ["Jonathan Colby"]
+  spec.email         = ["jcolby@team.mobile.de"]
+
+  spec.summary       = %q{Ruby API library for Panteras PaaS platform.}
+  spec.description   = %q{A convenient api for getting information from consul, mesos, marathon, and docker in the Panteras PaaS infrastructure.}
+  spec.homepage      = "https://github.com/joncolby/panteras_api"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+#  spec.bindir        = "bin"
+#  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+ # if spec.respond_to?(:metadata)
+ #   spec.metadata['allowed_push_host'] = "TODO: Set to 'http://mygemserver.com' to prevent pushes to rubygems.org, or delete to allow pushes to any server."
+ # end
+
+  spec.add_development_dependency "bundler", "~> 1.8"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: panteras_api
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Jonathan Colby
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-08-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: A convenient api for getting information from consul, mesos, marathon,
+  and docker in the Panteras PaaS infrastructure.
+email:
+- jcolby@team.mobile.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- extra/mesos_consul_consistency_check
+- extra/mesos_consul_consistency_check_nagios_wrapper
+- lib/panteras_api.rb
+- lib/panteras_api/consul_cluster.rb
+- lib/panteras_api/docker_host.rb
+- lib/panteras_api/http_utils.rb
+- lib/panteras_api/marathon_endpoint.rb
+- lib/panteras_api/mesos_cluster.rb
+- lib/panteras_api/utils.rb
+- lib/panteras_api/version.rb
+- panteras_api.gemspec
+homepage: https://github.com/joncolby/panteras_api
+licenses: []
+metadata: {}
+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.5
+signing_key: 
+specification_version: 4
+summary: Ruby API library for Panteras PaaS platform.
+test_files: []