port-authority 0.4.8 → 0.5.0

data/lib/port-authority/manager/threads/icmp.rb

@@ -1,30 +0,0 @@
-# rubocop:disable Metrics/MethodLength
-require 'net/ping'
-
-module PortAuthority
-  module Manager
-    module Threads
-      def thread_icmp
-        Thread.new do
-          Thread.current[:name] = 'icmp'
-          begin
-            info 'starting ICMP thread...'
-            icmp = Net::Ping::ICMP.new(@config[:vip][:ip])
-            until @exit
-              debug 'checking state by ICMP echo'
-              status = vip_alive? icmp
-              @semaphore[:icmp].synchronize { @status_icmp = status }
-              debug "VIP is #{status ? 'alive' : 'down'} according to ICMP"
-              sleep @config[:icmp][:interval]
-            end
-            info 'ending ICMP thread...'
-          rescue StandardError => e
-            alert "#{e.class}: #{e.message}"
-            alert e.backtrace
-            @exit = true
-          end
-        end
-      end
-    end
-  end
-end

data/lib/port-authority/manager/threads/swarm.rb

@@ -1,35 +0,0 @@
-# rubocop:disable Metrics/MethodLength
-module PortAuthority
-  module Manager
-    module Threads
-      def thread_swarm
-        Thread.new do
-          Thread.current[:name] = 'swarm'
-          info 'starting swarm thread...'
-          begin
-            etcd = etcd_connect!
-            until @exit
-              debug 'checking swarm state'
-              status = am_i_leader? etcd
-              @semaphore[:swarm].synchronize { @status_swarm = status }
-              debug "i am #{status ? '' : 'NOT' } the swarm leader"
-              sleep @config[:etcd][:interval]
-            end
-            info 'ending swarm thread...'
-          rescue PortAuthority::Errors::ETCDConnectFailed => e
-            err "#{e.class}: #{e.message}"
-            err "connection: " + e.etcd.to_s
-            err "  #{e.backtrace.to_s}"
-            @semaphore[:swarm].synchronize { @status_swarm = false }
-            sleep @config[:etcd][:interval]
-            retry unless @exit
-          rescue StandardError => e
-            alert e.message
-            alert e.backtrace.to_s
-            @exit = true
-          end
-        end
-      end
-    end
-  end
-end

data/lib/port-authority/util/config.rb

@@ -1,62 +0,0 @@
-require 'yaml'
-require 'etcd-tools'
-
-module PortAuthority
-  module Util
-    module Config
-
-      def config
-        cfg = default_config
-        if File.exist? '/etc/port-authority.yaml'
-          cfg = cfg.deep_merge YAML.load_file('/etc/port-authority.yaml')
-          puts 'loaded config from /etc/port-authority.yaml'
-        elsif File.exist? './port-authority.yaml'
-          cfg = cfg.deep_merge YAML.load_file('./port-authority.yaml')
-          puts 'loaded config from ./port-authority.yaml'
-        else
-          puts 'no config file loaded, using defaults'
-        end
-        cfg
-      end
-
-      private
-
-      def default_config
-        { debug: false,
-          syslog: false,
-          etcd: {
-            endpoints: ['http://localhost:2379'],
-            interval: 5,
-            timeout: 5
-          },
-          icmp: {
-            count: 5,
-            interval: 2
-          },
-          arping: {
-            count: 1,
-            wait: 1
-          },
-          vip: {
-            interval: 1,
-            ip: '172.17.1.5',
-            mask: '255.255.255.0',
-            interface: 'eth0'
-          },
-          lb: {
-            image: 'docker-registry.prz/stackdocks/haproxy:latest',
-            name: 'lb',
-            network: 'overlay',
-            docker_endpoint: 'unix:///var/run/docker.sock',
-            log_dest: '',
-          },
-          commands: {
-            arping: `which arping`.chomp,
-            arp: `which arp`.chomp,
-            iproute: `which ip`.chomp
-          }
-        }
-      end
-    end
-  end
-end

data/lib/port-authority/util/etcd.rb

@@ -1,50 +0,0 @@
-require 'etcd'
-require 'etcd-tools/mixins'
-
-module PortAuthority
-  module Util
-    module Etcd
-      # connect to ETCD
-      def etcd_connect!
-        endpoints = @config[:etcd][:endpoints].map { |e| e = e.gsub!(/^https?:\/\//, '').gsub(/\/$/, '').split(':'); { host: e[0], port: e[1].to_i } }
-        debug "parsed ETCD endpoints: #{endpoints.to_s}"
-        etcd = ::Etcd::Client.new(cluster: endpoints, read_timeout: @config[:etcd][:timeout])
-        etcd if etcd.version
-      rescue
-        raise PortAuthority::Errors::ETCDConnectFailed.new(@config[:etcd][:endpoints])
-      end
-
-      def etcd_healthy?(etcd)
-        raise PortAuthority::Errors::ETCDIsSick.new(@config[:etcd][:endpoints]) unless etcd.healthy?
-      end
-
-      def swarm_leader(etcd)
-        etcd.get('/_pa/docker/swarm/leader').value
-      end
-
-      def am_i_leader?(etcd)
-        Socket.ip_address_list.map(&:ip_address).member?(swarm_leader(etcd).split(':').first)
-      end
-
-      def overlay_id(etcd, name)
-        etcd.get_hash('/_pa/docker/network/v1.0/network').each_value do |network|
-          return network['id'] if network['name'] == name
-        end
-      end
-
-      def list_services(etcd, network, service_name='.*')
-        svc_filter = Regexp.new(service_name)
-        network_id = overlay_id(etcd, network)
-        services = Hash.new
-        etcd.get_hash("/_pa/docker/network/v1.0/endpoint/#{network_id}").each_value do |container|
-          next unless svc_filter.match container['name']
-          services[container['name']] = Hash.new
-          services[container['name']]['id'] = container['id']
-          services[container['name']]['ip'] = container['ep_iface']['addr'].sub(/\/[0-9]+$/, '')
-          services[container['name']]['ports'] = container['exposed_ports'].map { |port| port['Port'] }
-        end
-        services
-      end
-    end
-  end
-end

data/lib/port-authority/util/helpers.rb

@@ -1,27 +0,0 @@
-require 'socket'
-
-module PortAuthority
-  module Util
-    module Helpers
-      def hostname
-        @hostname ||= Socket.gethostname
-      end
-
-      def my_ip
-        @my_ip ||= Socket.ip_address_list.detect(&:ipv4_private?).ip_address
-      end
-
-      def arping
-        @config[:commands][:arping]
-      end
-
-      def iproute
-        @config[:commands][:iproute]
-      end
-
-      def arp
-        @config[:commands][:arp]
-      end
-    end
-  end
-end

data/lib/port-authority/util/loadbalancer.rb

@@ -1,78 +0,0 @@
-require 'docker-api'
-
-module PortAuthority
-  module Util
-    module LoadBalancer
-      # connect to Docker
-      def lb_docker_setup!
-        Docker.url = @config[:lb][:docker_endpoint]
-        Docker.version
-        true
-      rescue
-        false
-      end
-
-      def lb_update!
-        lb_stop! if lb_up?
-        lb_remove!
-        lb_create!
-        @lb_update_hook = false
-      end
-
-      def lb_remove!
-        Docker::Container.get(@config[:lb][:name]).delete
-      rescue Docker::Error::NotFoundError
-      end
-
-
-      def lb_create!
-        lb_remove!
-        img = Docker::Image.create('fromImage' => @config[:lb][:image])
-
-        # setup port bindings hash
-        port_bindings = Hash.new
-        img.json['ContainerConfig']['ExposedPorts'].keys.each do |port|
-          port_bindings[port] = [ { 'HostPort' => "#{port.split('/').first}" } ]
-        end
-
-        cont_def = {
-          'Image' => img.json['Id'],
-          'name' => @config[:lb][:name],
-          'Hostname' => @config[:lb][:name],
-          'Env' => [ "ETCDCTL_ENDPOINT=#{@config[:etcd][:endpoints].map { |e| "http://#{e}" }.join(',')}" ],
-          'RestartPolicy' => { 'Name' => 'never' },
-          'HostConfig' => {
-            'PortBindings' => port_bindings,
-            'NetworkMode' => @config[:lb][:network]
-          }
-        }
-
-        if @config[:lb][:log_dest] != ''
-          cont_def['HostConfig']['LogConfig'] = {
-            'Type' => 'gelf',
-            'Config' => {
-              'gelf-address' => @config[:lb][:log_dest],
-              'tag' =>  Socket.gethostbyname(Socket.gethostname).first + '/{{.Name}}/{{.ID}}'
-            }
-          }
-        end
-
-        # create container with
-        @lb_container = Docker::Container.create(cont_def)
-      end
-
-      def lb_up?
-        @lb_container.json['State']['Running']
-      end
-
-      def lb_start!
-        @lb_container.start
-      end
-
-      def lb_stop!
-        @lb_container.stop
-      end
-
-    end
-  end
-end

data/lib/port-authority/util/logger.rb

@@ -1,57 +0,0 @@
-# rubocop:disable Metrics/LineLength, Metrics/AbcSize, Metrics/MethodLength
-require 'syslog'
-
-module PortAuthority
-  module Util
-    module Logger
-      def debug(message)
-        log :debug, message if @config[:debug]
-      end
-
-      def info(message)
-        log :info, message
-      end
-
-      def notice(message)
-        log :notice, message
-      end
-
-      def err(message)
-        log :err, message
-      end
-
-      def alert(message)
-        log :alert, message if @config[:debug]
-      end
-
-      def syslog_init(proc_name)
-        Syslog.open(proc_name, Syslog::LOG_PID, Syslog::LOG_DAEMON)
-      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 :err
-            l = Syslog::LOG_ERR
-          when :alert
-            l = Syslog::LOG_ALERT
-          end
-          @semaphore[:log].synchronize do
-            Syslog.log(l, "(%s) %s", Thread.current[:name], msg.to_s)
-          end
-        else
-          @semaphore[:log].synchronize do
-            $stdout.puts("#{Time.now.to_s} #{lvl.to_s[0].capitalize} (#{Thread.current[:name]}) #{msg.to_s}")
-            $stdout.flush
-          end
-        end
-      end
-    end
-  end
-end

data/lib/port-authority/util/vip.rb

@@ -1,57 +0,0 @@
-# rubocop:disable Metrics/LineLength, Metrics/AbcSize
-module PortAuthority
-  module Util
-    module Vip
-      # add or remove VIP on interface
-      # <IMPLEMENTED>
-      def vip_handle!(leader)
-        ip = IPAddr.new(@config[:vip][:ip])
-        mask = @config[:vip][:mask]
-        cmd = [iproute, 'address', '', "#{ip}/#{mask}", 'dev', @config[:vip][:interface], 'label', @config[:vip][:interface] + '-vip', '>/dev/null 2>&1']
-        leader ? cmd[2] = 'add' : cmd[2] = 'delete'
-        debug "#{cmd.join(' ')}"
-        if system(cmd.join(' '))
-          return true
-        else
-          return false
-        end
-      end
-
-      # send gratuitous ARP to the network
-      def vip_update_arp!
-        cmd = [arping, '-U', '-q', '-c', @config[:arping][:count], '-I', @config[:vip][:interface], @config[:vip][:ip]]
-        debug "#{cmd.join(' ')}"
-        if system(cmd.join(' '))
-          return true
-        else
-          return false
-        end
-      end
-
-      # check whether VIP is assigned to me
-      def got_vip?
-        Socket.ip_address_list.map(&:ip_address).member?(@config[:vip][:ip])
-      end
-
-      # check reachability of VIP by ICMP echo
-      def vip_alive?(icmp)
-        (1..@config[:icmp][:count]).each { return true if icmp.ping }
-        false
-      end
-
-      # check whether the IP is registered anywhere
-      def vip_dup?
-        cmd_arp = [arp, '-d', @config[:vip][:ip], '>/dev/null 2>&1']
-        cmd_arping = [arping, '-D', '-q', '-c', @config[:arping][:count], '-w', @config[:arping][:wait], '-I', @config[:vip][:interface], @config[:vip][:ip]]
-        debug "#{cmd_arp.join(' ')}"
-        system(cmd_arp.join(' '))
-        debug "#{cmd_arping.join(' ')}"
-        if system(cmd_arping.join(' '))
-          return false
-        else
-          return true
-        end
-      end
-    end
-  end
-end