port-authority-prz 0.5.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a097763b4216a171c756f1fa93c8d1f9bcf2d2a9
+  data.tar.gz: 32ba35072e6168e7e0d59625b7c19cbc157a6eb8
+SHA512:
+  metadata.gz: f7de62fe39132a46cf906f89038111ceb3956d10e7783f79b9265a125df00ff9422fd85aa932251ba983e4999e7e249bc432a5b12d2859b341837f2fa1a25a22
+  data.tar.gz: 1c3c05227f3efc65fa3f3c5d8cf06b9a91d0f341f83c11b1a8640b93071790b3ebdf0197d4f4bd8fdeb3f719812863fce290451d965cf6f0b4c9061ff7bfb179

data/bin/pa-lbaas-agent

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require 'port-authority/agents/lbaas'
+PortAuthority::Agents::LBaaS.new

data/bin/pa-service-list

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require 'port-authority/tools/service_list'
+PortAuthority::Tools::ServiceList.new

data/lib/port-authority/agent.rb

@@ -0,0 +1,154 @@
+require 'timeout'
+require 'json'
+require 'yaml'
+require 'port-authority'
+require 'port-authority/config'
+require 'port-authority/logger'
+require 'port-authority/etcd'
+
+module PortAuthority
+  # Scaffolding class for agents
+  class Agent
+    # Common agent process init. Contains configuration load,
+    # common signal responses and runtime variables init.
+    # Implements execution of actual agents via \+run+ method.
+    # Also handles any uncaught exceptions.
+    def initialize
+      Thread.current[:name] = 'main'                        # name main thread
+      @@_exit = false                                       # prepare exit flag
+      @@_semaphores = { log: Mutex.new }                    # init semaphores
+      @@_threads = {}                                       # init threads
+      Signal.trap('INT') { exit!(1) }                       # end immediatelly
+      Signal.trap('TERM') { end! }                          # end gracefully
+      Config.load! || exit!(1)                              # load config or die
+      begin                                                 # all-wrapping exception ;)
+        run                                                 # hook to child class
+      rescue StandardError => e
+        Logger.alert "UNCAUGHT EXCEPTION IN THREAD main! Dying!  X.X"
+        Logger.alert [' ', "#{e.class}:", e.message].join(' ')
+        e.backtrace.each {|line| Logger.debug "  #{line}"}
+        exit! 1
+      end
+    end
+
+    # Setup the agent process.
+    # Initializes logging, system process parameters,
+    # daemonizing.
+    #
+    # There are 4 optional parameters:
+    # +:name+:: \+String+ Agent name. Defaults to \+self.class.downcase+ of the child agent
+    # +:root+:: \+Bool+ Require to be ran as root. Defaults to \+false+.
+    # +:daemonize+:: \+Bool+ Daemonize the process. Defaults to \+false+.
+    # +:nice+:: \+Int+ nice of the process. Defaults to \+0+
+    def setup(args = {})
+      name = args[:name] || self.class.to_s.downcase.split('::').last
+      args[:root] ||= false
+      args[:daemonize] ||= false
+      args[:nice] ||= 0
+      Logger.init! @@_semaphores[:log], name
+      Logger.info 'Starting main thread'
+      Logger.debug 'Setting process name'
+      if RUBY_VERSION >= '2.1'
+        Process.setproctitle("pa-#{name}-agent")
+      else
+        $0 = "pa-#{name}-agent"
+      end
+      if args[:root] && Process.uid != 0
+        Logger.alert 'Must run under root user!'
+        exit! 1
+      end
+      Logger.debug 'Setting CPU nice level'
+      Process.setpriority(Process::PRIO_PROCESS, 0, args[:nice])
+      if args[:daemonize]
+        Logger.info 'Daemonizing process'
+        if RUBY_VERSION < '1.9'
+          exit if fork
+          Process.setsid
+          exit if fork
+          Dir.chdir('/')
+        else
+          Process.daemon
+        end
+      end
+    end
+
+    # Has the exit flag been raised?
+    def exit?
+      @@_exit
+    end
+
+    # Raise the exit flag
+    def end!
+      @@_exit = true
+    end
+
+    # Create a named \+Mutex+ semaphore
+    def sem_create(name)
+      @@_semaphores.merge!(Hash[name.to_sym], Mutex.new)
+    end
+
+    # Create a named \+Thread+ with its \+Mutex+ semaphore.
+    # The definition includes \+&block+ of code that should run
+    # within the thread.
+    #
+    # The method requires 3 parameters:
+    # +name+:: \+Symbol+ Thread/Mutex name.
+    # +interval+:: \+Integer+ Thread loop interval.
+    # +&block+:: \+Proc+ Block of code to run.
+    def thr_create(name, interval, &block)
+      @@_semaphores.merge!(Hash[name.to_sym, Mutex.new])
+      @@_threads.merge!(Hash[name.to_sym, Thread.new do
+          Thread.current[:name] = name.to_s
+          Logger.info "Starting thread #{Thread.current[:name]}"
+          begin
+            until exit?
+              yield block
+              sleep interval
+            end
+            Logger.info "Ending thread #{Thread.current[:name]}"
+          rescue StandardError => e
+            Logger.alert "UNCAUGHT EXCEPTION IN THREAD #{Thread.current[:name]}"
+            Logger.alert [' ', "#{e.class}:", e.message].join(' ')
+            e.backtrace.each {|line| Logger.debug "  #{line}"}
+            end!
+          end
+        end
+      ])
+    end
+
+    # Run thread-safe code.
+    # The \+name+ parameter can be omitted when used
+    # from within a block of thread code. In this case
+    # the Mutex with the same \+:name+ will be used.
+    #
+    # The method accepts following parameters:
+    # +name+:: \+Symbol+ Mutex name.
+    # +&block+:: \+Proc+ Block of code to run.
+    def thr_safe(name=Thread.current[:name].to_sym, &block)
+      @@_semaphores[name.to_sym].synchronize do
+        yield block
+      end
+    end
+
+    # Start named thread.
+    # If the name is omitted, applies to all spawned threads ;)
+    def thr_start(name=nil)
+      return @@_threads[name].run if name
+      @@_threads.each_value(&:run)
+    end
+
+
+    # Wait for named thread to finish.
+    # If the name is omitted, applies to all spawned threads ;)
+    def thr_wait(name=nil)
+      return @@_threads[name].join if name
+      @@_threads.each_value(&:join)
+    end
+
+    # Return hostname.
+    def hostname
+      @hostname ||= Socket.gethostname
+    end
+
+  end
+end

data/lib/port-authority/agents/lbaas.rb

@@ -0,0 +1,133 @@
+# rubocop:disable MethodLength, CyclomaticComplexity, Metrics/BlockNesting, Metrics/LineLength, Metrics/AbcSize, Metrics/PerceivedComplexity
+require 'socket'
+require 'port-authority/agent'
+require 'port-authority/mechanism/load_balancer'
+require 'port-authority/mechanism/floating_ip'
+
+module PortAuthority
+  module Agents
+    class LBaaS < PortAuthority::Agent
+      include PortAuthority::Mechanism
+
+      def run
+        setup(daemonize: Config.daemonize, nice: -10, root: true)
+        Signal.trap('HUP') { Config.load! && LoadBalancer.init! && FloatingIP.init! }
+        Signal.trap('USR1') { Logger.debug! }
+        Signal.trap('USR2') { @lb_update_hook = true }
+        @status_swarm = false
+        @etcd = PortAuthority::Etcd.cluster_connect Config.etcd
+
+        thr_create(:swarm, Config.lbaas[:swarm_interval] || Config.lbaas[:interval]) do
+          begin
+            Logger.debug 'Checking Swarm state'
+            status = @etcd.am_i_swarm_leader?
+            thr_safe { @status_swarm = status }
+            Logger.debug "I am Swarm #{status ? 'leader' : 'follower' }"
+          rescue StandardError => e
+            Logger.error [ e.class, e.message ].join(': ')
+            e.backtrace.each {|line| Logger.debug "  #{line}"}
+            thr_safe { @status_swarm = false }
+            sleep(Config.lbaas[:swarm_interval] || Config.lbaas[:interval])
+            retry unless exit?
+          end
+        end
+
+        thr_start
+
+        FloatingIP.init!
+        LoadBalancer.init!
+
+        Logger.debug 'Waiting for threads to gather something...'
+        sleep Config.lbaas[:interval]
+        first_cycle = true
+        status_time = Time.now.to_i - 60
+
+        until exit?
+          status_swarm = false if first_cycle
+          if @lb_update_hook
+            Logger.notice 'LoadBalancer update triggerred'
+            LoadBalancer.update!
+            @lb_update_hook = false
+            Logger.notice 'LoadBalancer update finished'
+          end
+          sleep Config.lbaas[:interval]
+          thr_safe(:swarm) { status_swarm = @status_swarm }
+          # main logic
+          if status_swarm
+            # handle FloatingIP on leader
+            Logger.debug 'I am the LEADER'
+            if FloatingIP.up?
+              Logger.debug 'Got FloatingIP, that is OK'
+            else
+              Logger.notice 'No FloatingIP here, checking whether it is free'
+              FloatingIP.arp_del!
+              if FloatingIP.reachable?
+                Logger.notice 'FloatingIP is still up! (ICMP)'
+              else
+                Logger.info 'FloatingIP is unreachable by ICMP, checking for duplicates on L2'
+                FloatingIP.arp_del!
+                if FloatingIP.duplicate?
+                  Logger.error 'FloatingIP is still assigned! (ARP)'
+                else
+                  Logger.notice 'FloatingIP is free :) assigning'
+                  FloatingIP.handle! status_swarm
+                  Logger.notice 'Notifying the network about change'
+                  FloatingIP.arp_update!
+                end
+              end
+            end
+            # handle LoadBalancer on leader
+            if LoadBalancer.up?
+              Logger.debug 'LoadBalancer is up, that is OK'
+            else
+              Logger.notice 'LoadBalancer is down, starting'
+              LoadBalancer.start!
+            end
+          else
+            # handle FloatingIP on follower
+            Logger.debug 'I am a follower'
+            if FloatingIP.up?
+              Logger.notice 'I got FloatingIP and should not, removing'
+              FloatingIP.handle! status_swarm
+              FloatingIP.arp_del!
+              Logger.notice 'Notifying the network about change'
+              FloatingIP.update_arp!
+            else
+              Logger.debug 'No FloatingIP here, that is OK'
+            end
+            # handle LoadBalancer on follower
+            if LoadBalancer.up?
+              Logger.notice 'LoadBalancer is up, stopping'
+              LoadBalancer.stop!
+            else
+              Logger.debug 'LoadBalancer is down, that is OK'
+            end
+          end # logic end
+        end
+
+        thr_wait
+
+        # remove FloatingIP on shutdown
+        if FloatingIP.up?
+          Logger.notice 'Removing FloatingIP'
+          FloatingIP.handle! false
+          FloatingIP.update_arp!
+        end
+
+        # stop LB on shutdown
+        if LoadBalancer.up?
+          Logger.notice 'Stopping LoadBalancer'
+          LoadBalancer.stop!
+        end
+
+        Logger.notice 'Exiting...'
+        exit 0
+      end
+
+      def my_ip
+        @my_ip ||= Socket.ip_address_list.detect(&:ipv4_private?).ip_address
+      end
+
+    end
+  end
+end

data/lib/port-authority/config.rb

@@ -0,0 +1,49 @@
+require 'etcd-tools/mixins/hash'
+
+module PortAuthority
+  module Config
+
+    extend self
+
+    attr_reader :_cfg
+
+    def method_missing(name, *_args, &_block)
+      return @_cfg[name.to_sym] if @_cfg[name.to_sym] != nil
+      fail(NoMethodError, "unknown configuration section #{name}", caller)
+    end
+
+    def load!
+      @_cfg = {
+        debug: false,
+        syslog: false,
+        daemonize: false,
+        etcd: {
+          endpoints: ['http://localhost:2379'],
+          timeout: 5
+        },
+        commands: {
+          arping: `which arping`.chomp,
+          arp: `which arp`.chomp,
+          iproute: `which ip`.chomp
+        }
+      }
+      files = ['/etc/port-authority.yaml', './etc/port-authority.yaml'].delete_if {|f| !File.exists?(f)}
+      dir_files = Dir['/etc/port-authority.d/**.yaml'] + Dir['./etc/port-authority.d/**.yaml']
+      files += dir_files
+      return false if files.empty?
+      files.each do |f|
+        @_cfg = @_cfg.deep_merge(YAML.load_file(f))
+      end
+      true
+    end
+
+    def dump
+      self._cfg
+    end
+
+    def to_yaml
+      self._cfg.to_yaml.to_s
+    end
+
+  end
+end

data/lib/port-authority/etcd.rb

@@ -0,0 +1,47 @@
+require 'etcd-tools'
+require 'etcd-tools/mixins'
+
+module PortAuthority
+  class Etcd < Etcd::Client
+
+    def self.cluster_connect(config)
+      endpoints = config[:endpoints].map {|ep| Hash[[:host, :port].zip(ep.match(/^(?:https?:\/\/)?([0-9a-zA-Z\.-_]+):([0-9]+)\/?/).captures)]}
+      timeout = config[:timeout].to_i
+      PortAuthority::Etcd.new(cluster: endpoints, read_timeout: timeout)
+    end
+
+    def self.shell_cluster_connect(env, timeout = 2)
+      env.split(',').each do |u|
+        (host, port) = u.gsub(/^https?:\/\//, '').gsub(/\/$/, '').split(':')
+        etcd = PortAuthority::Etcd.new(cluster: [{ host: host, port: port }], read_timeout: timeout)
+        return etcd if etcd.healthy?
+        next
+      end
+      raise Etcd::ClusterConnectError
+    end
+
+
+    def swarm_leader
+      get('/_pa/docker/swarm/leader').value.split(':').first
+    end
+
+    def am_i_swarm_leader?
+      Socket.ip_address_list.map(&:ip_address).member?(swarm_leader)
+    end
+
+    def swarm_overlay_id(name)
+      get_hash('/_pa/docker/network/v1.0/network').each_value do |network|
+        return network['id'] if network['name'] == name
+      end
+    end
+
+    def swarm_list_services(network, service_name='.*')
+      services = {}
+      self.get_hash("/_pa/docker/network/v1.0/endpoint/#{swarm_overlay_id(network)}").each_value do |container|
+        next unless Regexp.new(service_name).match container['name']
+        services = { container['name'] => { 'id' => container['id'], 'ip' => container['ep_iface']['addr'].sub(/\/[0-9]+$/, ''), 'ports' => container['exposed_ports'].map { |port| port['Port'] } } }
+      end
+      services
+    end
+  end
+end

data/lib/port-authority/logger.rb

@@ -0,0 +1,56 @@
+# rubocop:disable Metrics/LineLength, Metrics/AbcSize, Metrics/MethodLength
+require 'syslog'
+
+module PortAuthority
+  module Logger
+
+    extend self
+
+    def init!(s,n)
+      @_s = s
+      @debug = Config.debug
+      Syslog.open("pa-#{n}-agent", Syslog::LOG_PID, Syslog::LOG_DAEMON) if Config.syslog
+    end
+
+    def debug!
+      @debug = !@debug
+    end
+
+    def debug(message)
+      log :debug, message if @debug
+    end
+
+    def method_missing(name, *args, &_block)
+      if name
+        return log(name.to_sym, args[0])
+      else
+        fail(NoMethodError, "Unknown Logger method '#{name}'", caller)
+      end
+    end
+
+    def log(lvl, msg)
+      if Config.syslog
+        case lvl
+        when :debug
+          l = Syslog::LOG_DEBUG
+        when :info
+          l = Syslog::LOG_INFO
+        when :notice
+          l = Syslog::LOG_NOTICE
+        when :error
+          l = Syslog::LOG_ERR
+        when :alert
+          l = Syslog::LOG_ALERT
+        end
+        @_s.synchronize do
+          Syslog.log(l, "(%s) %s", Thread.current[:name], msg.to_s)
+        end
+      else
+        @_s.synchronize do
+          $stdout.puts [Time.now.to_s, sprintf('%-6.6s', lvl.to_s.upcase), "(#{Thread.current[:name]})", msg.to_s].join(' ')
+          $stdout.flush
+        end
+      end
+    end
+  end
+end

data/lib/port-authority/mechanism/floating_ip.rb

@@ -0,0 +1,65 @@
+# rubocop:disable Metrics/LineLength, Metrics/AbcSize
+require 'net/ping'
+require 'digest/sha2'
+
+module PortAuthority
+  module Mechanism
+    module FloatingIP
+
+      extend self
+
+      attr_accessor :_icmp
+
+      def init!
+        @_icmp = Net::Ping::ICMP.new(Config.lbaas[:floating_ip])
+        Logger.debug(Config.lbaas.to_yaml)
+      end
+
+      # add or remove VIP on interface
+      def handle!(leader)
+        return true if shellcmd Config.commands[:iproute], 'address', leader ? 'add' : 'delete', "#{Config.lbaas[:floating_ip]}/32", 'dev', Config.lbaas[:floating_iface], '>/dev/null 2>&1'
+        false
+      end
+
+      # send gratuitous ARP to the network
+      def arp_update!
+        return true if shellcmd Config.commands[:arping], '-U', '-q', '-c', Config.lbaas[:arping_count], '-I', Config.lbaas[:floating_iface], Config.lbaas[:floating_ip]
+
+        false
+      end
+
+      # check whether VIP is assigned to me
+      def up?
+        Socket.ip_address_list.map(&:ip_address).member?(Config.lbaas[:floating_ip])
+      end
+
+      # check reachability of VIP by ICMP echo
+      def reachable?
+        (1..Config.lbaas[:icmp_count]).each { return true if @_icmp.ping }
+        false
+      end
+
+      def arp_del!
+        return true if shellcmd Config.commands[:arp], '-d', Config.lbaas[:floating_ip], '>/dev/null 2>&1'
+        false
+      end
+
+      # check whether the IP is registered anywhere
+      def duplicate?
+        return false if shellcmd Config.commands[:arping], '-D', '-q', '-c', Config.lbaas[:arping_count], '-w', Config.lbaas[:arping_wait], '-I', Config.lbaas[:floating_iface], Config.lbaas[:floating_ip]
+        true
+      end
+
+      private
+      def shellcmd(*args)
+        cmd = args.join(' ').to_s
+        cksum = Digest::SHA256.hexdigest(args.join.to_s)[0..15]
+        Logger.debug "Executing shellcommand #{cksum} - #{cmd}"
+        ret = system cmd
+        Logger.debug "Shellcommand #{cksum} returned #{ret.to_s}"
+        return ret
+      end
+
+    end
+  end
+end

data/lib/port-authority/mechanism/load_balancer.rb

@@ -0,0 +1,90 @@
+require 'docker-api'
+
+module PortAuthority
+  module Mechanism
+    module LoadBalancer
+
+      extend self
+
+      attr_reader :_container, :_container_def, :_image
+
+      def init!
+        Docker.url = Config.lbaas[:docker_endpoint]
+        Docker.options = { connect_timeout: Config.lbaas[:docker_timeout] || 10 }
+        self.container || ( self.pull! && self.create! )
+      end
+
+      def container
+        @_container ||= Docker::Container.get(Config.lbaas[:name]) rescue nil
+      end
+
+      def image
+        @_image ||= Docker::Image.create('fromImage' => Config.lbaas[:image])
+      end
+
+      def pull!
+        @_image = Docker::Image.create('fromImage' => Config.lbaas[:image])
+      end
+
+      def create!
+        port_bindings = Hash.new
+        self.image.json['ContainerConfig']['ExposedPorts'].keys.each do |port|
+          port_bindings[port] = [ { 'HostPort' => "#{port.split('/').first}" } ]
+        end
+        @_container_def = {
+          'Image' => self.image.json['Id'],
+          'name' => Config.lbaas[:name],
+          'Hostname' => Config.lbaas[:name],
+          'Env' => [ "ETCDCTL_ENDPOINT=#{Config.etcd[:endpoints].join(',')},#{Config.lbaas[:env]}" ],
+          'RestartPolicy' => { 'Name' => 'never' },
+          'HostConfig' => {
+            'PortBindings' => port_bindings,
+            'NetworkMode' => Config.lbaas[:network]
+          }
+        }
+        if Config.lbaas[:log_dest] != ''
+          @_container_def['HostConfig']['LogConfig'] = {
+            'Type' => 'gelf',
+            'Config' => {
+              'gelf-address' => Config.lbaas[:log_dest],
+              'tag' =>  Socket.gethostbyname(Socket.gethostname).first + '/{{.Name}}/{{.ID}}'
+            }
+          }
+        end
+        @_container = Docker::Container.create(@_container_def)
+      end
+
+
+      def update!
+        begin
+          ( self.stop! && start = true ) if self.up?
+          self.remove!
+          self.pull!
+          self.create!
+          self.start! if start == true
+        rescue StandardError => e
+          Logger.error "UNCAUGHT EXCEPTION IN THREAD #{Thread.current[:name]}"
+          Logger.error [' ', e.class, e.message].join(' ')
+          Logger.error '  ' + e.backtrace.to_s
+        end
+      end
+
+      def remove!
+        @_container.delete
+      end
+
+      def up?
+        @_container.json['State']['Running']
+      end
+
+      def start!
+        @_container.start
+      end
+
+      def stop!
+        @_container.stop
+      end
+
+    end
+  end
+end

data/lib/port-authority/tool.rb

@@ -0,0 +1,9 @@
+module PortAuthority
+  class Tool
+    def initialize
+      self.optparse
+      @ARGS = ARGV
+      self.run
+    end
+  end
+end

data/lib/port-authority/tools/service_list.rb

@@ -0,0 +1,93 @@
+require 'optparse'
+require 'json'
+require 'yaml'
+require 'etcd-tools'
+# require 'etcd-tools/mixins'
+require 'port-authority/etcd'
+require 'port-authority/tool'
+
+module PortAuthority
+  module Tools
+    class ServiceList < PortAuthority::Tool
+
+      attr_reader :etcd
+
+      def optparse
+        @options = Hash.new
+        @options[:url] = ENV['ETCDCTL_ENDPOINT']
+        @options[:url] ||= "http://127.0.0.1:2379"
+        @options[:output_yaml] = false
+        @options[:output_json] = false
+        @options[:ip_only] = false
+        @options[:ports] = false
+        @options[:service_filter] = '.*'
+
+        OptionParser.new do |opts|
+          opts.banner = "Lists\n\nUsage: #{$0} [OPTIONS] NETWORK_NAME"
+          opts.separator ""
+          opts.separator "Connection options:"
+          opts.on("-u", "--url URL", "URL endpoint of the ETCD service (ETCDCTL_ENDPOINT envvar also applies) [DEFAULT: http://127.0.0.1:2379]") do |param|
+            @options[:url] = param
+          end
+
+          opts.separator ""
+          opts.separator "Filter options:"
+          opts.on("-s SERVICE_NAME", "--service-filter SERVICE_NAME", String, "List only services by name") do |param|
+            @options[:service_filter] = param
+          end
+
+          opts.separator ""
+          opts.separator "Output options:"
+          opts.on("-i", "--ips", "List only IPs (text mode)") do
+            @options[:ip_only] = true
+          end
+          opts.on("-p", "--ports", "List exposed ports (text mode)") do
+            @options[:ports] = true
+          end
+          opts.on("-y", "--yaml", "Output the data as YAML") do
+            @options[:output_yaml] = true
+          end
+          opts.on("-j", "--json", "Output the data as JSON") do
+            @options[:output_json] = true
+          end
+
+          opts.separator ""
+          opts.separator "Common options:"
+          opts.on_tail("-h", "--help", "show usage") do |param|
+            puts opts
+            exit! 0
+          end
+        end.parse!
+      end
+
+      def run
+        unless @ARGS[0]
+          $stderr.puts 'Missing NETWORK_NAME!'
+          exit 1
+        end
+
+        @etcd = PortAuthority::Etcd.shell_cluster_connect(@options[:url])
+
+        services = @etcd.swarm_list_services(@ARGS[0], @options[:service_filter])
+
+        if @options[:output_yaml]
+          puts services.to_yaml
+        elsif @options[:output_json]
+          puts services.to_json
+        else
+          if @options[:ip_only]
+            services.each { |_, params| puts params['ip'] }
+          elsif @options[:ports]
+            services.each do |name, params|
+              params['ports'].each do |port|
+                puts "#{name} #{params['ip']}:#{port}"
+              end
+            end
+          else
+            services.each { |name, params| puts "#{name} #{params['ip']}" }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/port-authority.rb

@@ -0,0 +1,23 @@
+module PortAuthority
+
+  module Errors
+
+    class ETCDConnectFailed < StandardError
+      attr_reader :etcd, :message
+      def initialize(etcd, message = "Can't connect to ETCD")
+        @message = message
+        @etcd = etcd
+      end
+    end
+
+    class ETCDIsSick < StandardError
+      attr_reader :etcd, :message
+      def initialize(etcd, message = 'ETCD is not healthy')
+        @message = message
+        @etcd = etcd
+      end
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,139 @@
+--- !ruby/object:Gem::Specification
+name: port-authority-prz
+version: !ruby/object:Gem::Version
+  version: 0.5.4
+platform: ruby
+authors:
+- Radek 'blufor' Slavicinsky
+- Tomas 'arteal' Hejatko
+- Jan 'liquid' Kaufman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-06-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: etcd
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+- !ruby/object:Gem::Dependency
+  name: etcd-tools
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.4.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.4.4
+- !ruby/object:Gem::Dependency
+  name: net-ping
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.7.8
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.7.8
+- !ruby/object:Gem::Dependency
+  name: docker-api
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.25.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.25.0
+description: Highly opinionated PaaS based on Docker Swarm and ETCD
+email: devops@prozeta.eu
+executables:
+- pa-service-list
+- pa-lbaas-agent
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/pa-lbaas-agent
+- bin/pa-service-list
+- lib/port-authority.rb
+- lib/port-authority/agent.rb
+- lib/port-authority/agents/lbaas.rb
+- lib/port-authority/config.rb
+- lib/port-authority/etcd.rb
+- lib/port-authority/logger.rb
+- lib/port-authority/mechanism/floating_ip.rb
+- lib/port-authority/mechanism/load_balancer.rb
+- lib/port-authority/tool.rb
+- lib/port-authority/tools/service_list.rb
+homepage: https://github.com/prozeta/port-authority
+licenses:
+- GPLv2
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Port Authority
+test_files: []