iptables-web 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 60035381ec896cdd96b0892e60dd1cb43949f853
-  data.tar.gz: e211d23ba54a7b389323c7723df8b5565f9adf0d
+  metadata.gz: 16475aa736b21d189399f8b3c85279cfe14e6fe7
+  data.tar.gz: 9a726d97f74ce4611a3d25731ce82a94ed2a9983
 SHA512:
-  metadata.gz: 9d74bd5fc7379eddccefc52857f182196aa9bafdbf0c75eaf6e319fb5cef673919b93e8f568410c504985025137df3e32ebb5f8e93d76da97b149bc551dc05b0
-  data.tar.gz: f7c0656a71cd42fcf58bac89a39f5592ef7c4afb6f41b986b259be66b97f7c881c06e7e7cfa06ffd71f8ab461dead64bbce6f899dd46e847d477625589ed8e23
+  metadata.gz: b7f4461010b110bcebafec026d25dfd00ff1562ba2100eb6a88c0b5486266d5132eaed67277fda8134a616262c6815c1cb9605289bc659e119cfd4a15d719921
+  data.tar.gz: 5d6d6e84c2cf422f622a8cd8ab7e182f32f2791844f1fcce2186ccbd0acd9fc8ad1e2da5bc94517bb856cc710a0d27e1c659e79cd2418738a4a7457792da3f82

data/bin/iptables-web

@@ -1,100 +1,6 @@
 #!/usr/bin/env ruby
-require 'commander/import'
+
 require 'system/getifaddrs'
 require 'iptables_web'
-# :name is optional, otherwise uses the basename of this executable
-program :name, 'IPtables Web client'
-program :version, IptablesWeb::VERSION
-program :description, 'Update iptables '
-default_command :update
-command :install do |c|
-  c.syntax = 'iptables-web install'
-  c.description = 'Displays foo'
-  c.option '--force', 'Force config '
-  c.action do |args, options|
-    config = IptablesWeb::Configuration.new
-    api_url = ask('Api base url: ') { |q| q.default = config['api_base_url'] }
-    token = ask('Access token: ') { |q| q.default = config['access_token'] }
-    update_period = ask('Update every [min]', Integer) { |q| q.default = 1; q.in = 0..59 }
-    config_dir = IptablesWeb::Configuration.config_dir
-    unless File.exist?(config_dir)
-      say "Create config directory: #{config_dir}"
-      Dir.mkdir(config_dir)
-    end
-    config_file = File.join(config_dir, 'config.yml')
-    say "Write config to #{config_file}"
-    File.write config_file, <<CONFIG
-api_base_url: #{api_url}
-access_token: #{token}
-CONFIG
-    if system("LANG=C bash -l -c \"type rvm | cat | head -1 | grep -q '^rvm is a function$'\"")
-      wrapper = "#{ENV['HOME']}/.rvm/wrappers/#{`rvm current`.strip}/iptables-web"
-    else
-      wrapper = 'iptables-web'
-    end
-
-    cron_file = File.join(config_dir, 'cron.sh')
-    say "Write file #{cron_file}"
-    File.write cron_file, <<CONFIG
-#/bin/env ruby
-#{wrapper} update
-CONFIG
-    File.chmod(0700, cron_file)
-    say "Add cronjob #{cron_file}"
-    crontab = IptablesWeb::Crontab.new(false)
-    jobs = crontab.jobs
-    jobs.reject! { |job| job.include?('.iptables-web') }
-    jobs << "*/#{update_period} * * * * #{File.join(ENV['HOME'], '.iptables-web', 'cron.sh')}"
-    crontab.save(jobs)
-
-    static_rules = File.join(config_dir, 'static_rules')
-
-    say "Create file for static rules #{static_rules}"
-    say "* * * * * * * * * * * * * * * * * * * * * * * *\n"
-    say "* You can write predefined rules to this file.\n"
-    say "* This file will be concat with rules \n"
-    say "* See 'iptables-save' format.\n"
-    say "* * * * * * * * * * * * * * * * * * * * * * * * \n"
-
-    if File.exist?(static_rules) && !options.force
-      say 'File already exist!'
-    else
-      File.write static_rules, <<STATIC_RULES
-*filter
--A INPUT -i lo -j ACCEPT
--A FORWARD -i lo -j ACCEPT
--A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
--A FORWARD -m state --state ESTABLISHED,RELATED -j ACCEPT
-COMMIT
-STATIC_RULES
-    end
-  end
-end
-
-command :update do |c|
-  c.syntax = 'iptables-web update'
-  c.description = 'Display bar with optional prefix and suffix'
-  c.option '--config STRING', String, 'Path to config file'
-  c.option '--print', 'Show rules without restoring'
-  c.option '--force', 'Set rules omit checksum check'
-  c.action do |_, options|
-    IptablesWeb.configuration.load(options.config) if options.config
-    IptablesWeb::Model::Node.handshake do
-      rules = IptablesWeb::Model::AccessRule.all
-      iptables = IptablesWeb::Iptables.new
-      last_checksum = rules.response.headers[:etag].first
-      if options.print
-        say "Loading rules from #{IptablesWeb.configuration['api_base_url']}"
-        say 'Nothing changed.' if IptablesWeb::Configuration.checksum?(last_checksum)
-        say iptables.render(rules)
-      else
-        if IptablesWeb::Configuration.checksum?(rules.response.headers[:etag].first) && !options.force
-          say 'Skip iptables update. Nothing changed.'
-        else
-          iptables.restore(rules)
-          IptablesWeb::Configuration.checksum = last_checksum
-        end
-      end
-    end
-  end
-end
+require 'iptables_web/cli'
+IptablesWeb::Cli.new if $0 == __FILE__

data/lib/iptables_web.rb

@@ -1,3 +1,4 @@
+
 require 'iptables_web/version'
 require 'iptables_web/configuration'
 require 'system/getifaddrs'
@@ -8,20 +9,17 @@ require 'iptables_web/model/node'
 require 'iptables_web/crontab'
 require 'iptables_web/iptables'
 
-module IptablesWeb
-  class << self
-    attr_accessor :configuration
-    def configuration
-      self.configuration = Configuration.new unless @configuration
-      @configuration
-    end
+require 'commander'
+require 'iptables_web/cli/command/install'
+require 'iptables_web/cli/command/update'
+require 'iptables_web/cli/logged_output'
+require 'iptables_web/cli/import'
+require 'iptables_web/cli'
+
 
-    def configuration=(config)
-      @configuration = config
-      IptablesWeb::Model::Base.configure(config)
-      @configuration
-    end
-  end
+module IptablesWeb
+  extend Configuration
 end
 
-IptablesWeb.configuration =  IptablesWeb::Configuration.new #set default configuration
+IptablesWeb.reload
+

data/lib/iptables_web/cli.rb

@@ -0,0 +1,38 @@
+require 'commander'
+
+module IptablesWeb
+  class Cli
+    attr_reader :output
+    include ::Commander::Methods
+    include IptablesWeb::Cli::Command::Install
+    include IptablesWeb::Cli::Command::Update
+
+    def initialize
+      program :name, 'Iptables Web Client'
+      program :version, IptablesWeb::VERSION
+      program :description, 'Desc'
+      default_command :update
+
+      global_option('--config FILE', 'Configuration file') do |config|
+        IptablesWeb.config_path = config
+        IptablesWeb.reload
+      end
+
+      global_option('--log_file FILE', 'Log file path') do |log_path|
+        IptablesWeb.log_path = log_path
+      end
+
+      global_option('--host URL', 'Server base url') do |server_base_url|
+        IptablesWeb.api_base_url = server_base_url
+      end
+
+      global_option('--token TOKEN', 'Server base url') do |access_token|
+        IptablesWeb.access_token = access_token
+      end
+
+      install_command
+      update_command
+      run!
+    end
+  end
+end

data/lib/iptables_web/cli/command/install.rb

@@ -0,0 +1,73 @@
+module IptablesWeb
+  class Cli
+    module Command
+      module Install
+        def install_command
+          command :install do |c|
+            c.syntax = 'iptables-web install'
+            c.description = 'Displays foo'
+            c.option '--force', 'Force config '
+            c.action do |args, options|
+              config = IptablesWeb::Configuration.new
+              api_url = ask('Api base url: ') { |q| q.default = config['api_base_url'] }
+              token = ask('Access token: ') { |q| q.default = config['access_token'] }
+              update_period = ask('Update every [min]', Integer) { |q| q.default = 1; q.in = 0..59 }
+              config_dir = IptablesWeb::Configuration.config_dir
+              unless File.exist?(config_dir)
+                say "Create config directory: #{config_dir}"
+                Dir.mkdir(config_dir)
+              end
+              config_file = File.join(config_dir, 'config.yml')
+              say "Write config to #{config_file}"
+              File.write config_file, <<CONFIG
+api_base_url: #{api_url}
+access_token: #{token}
+CONFIG
+              if system("LANG=C bash -l -c \"type rvm | cat | head -1 | grep -q '^rvm is a function$'\"")
+                wrapper = "#{ENV['HOME']}/.rvm/wrappers/#{`rvm current`.strip}/iptables-web"
+              else
+                wrapper = 'iptables-web'
+              end
+
+              cron_file = File.join(config_dir, 'cron.sh')
+              say "Write file #{cron_file}"
+              File.write cron_file, <<CONFIG
+#/bin/env ruby
+#{wrapper} update
+CONFIG
+              File.chmod(0700, cron_file)
+              say "Add cronjob #{cron_file}"
+              crontab = IptablesWeb::Crontab.new(false)
+              jobs = crontab.jobs
+              jobs.reject! { |job| job.include?('.iptables-web') }
+              jobs << "*/#{update_period} * * * * #{File.join(ENV['HOME'], '.iptables-web', 'cron.sh')}"
+              crontab.save(jobs)
+
+              static_rules = File.join(config_dir, 'static_rules')
+
+              say "Create file for static rules #{static_rules}"
+              say "* * * * * * * * * * * * * * * * * * * * * * * *\n"
+              say "* You can write predefined rules to this file.\n"
+              say "* This file will be concat with rules \n"
+              say "* See 'iptables-save' format.\n"
+              say "* * * * * * * * * * * * * * * * * * * * * * * * \n"
+
+              if File.exist?(static_rules) && !options.force
+                say 'File already exist!'
+              else
+                File.write static_rules, <<STATIC_RULES
+*filter
+-A INPUT -i lo -j ACCEPT
+-A FORWARD -i lo -j ACCEPT
+-A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
+-A FORWARD -m state --state ESTABLISHED,RELATED -j ACCEPT
+COMMIT
+STATIC_RULES
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/iptables_web/cli/command/update.rb

@@ -0,0 +1,46 @@
+require 'iptables_web/cli/pid_file'
+module IptablesWeb
+  class Cli
+    module Command
+      module Update
+        def update_command
+          command :update do |c|
+            c.syntax = 'iptables-web update'
+            c.description = 'Display bar with optional prefix and suffix'
+            c.option '--config STRING', String, 'Path to config file'
+            c.option '--print', 'Show rules without restoring'
+            c.option '--force', 'Set rules omit checksum check'
+            c.action do |_, options|
+              begin
+
+                IptablesWeb.configuration.load(options.config) if options.config
+                logged_say "Use iptables server #{IptablesWeb.api_base_url}"
+                IptablesWeb.pid_file do
+                  IptablesWeb::Model::Node.handshake do
+                    rules = IptablesWeb::Model::AccessRule.all
+                    iptables = IptablesWeb::Iptables.new
+                    last_checksum = rules.response.headers[:etag].first
+                    if options.print
+                      logged_say 'Nothing changed.' if IptablesWeb.checksum?(last_checksum)
+                      say iptables.render(rules)
+                    else
+                      if IptablesWeb.checksum?(rules.response.headers[:etag].first) && !options.force
+                        logged_say 'Skip iptables update. Nothing changed.'
+                      else
+                        iptables.restore(rules)
+                        IptablesWeb.checksum = last_checksum
+                      end
+                    end
+                  end
+                end
+              rescue Exception => e
+                logged_say(e.message)
+                logged_say(e.backtrace.join("\n"))
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/iptables_web/cli/import.rb

@@ -0,0 +1,8 @@
+require 'highline'
+require 'forwardable'
+
+$terminal = IptablesWeb::Cli::LoggedOutput.new
+module Kernel
+  extend Forwardable
+  def_delegators :$terminal, :agree, :ask, :choose, :say, :logged_say
+end

data/lib/iptables_web/cli/logged_output.rb

@@ -0,0 +1,24 @@
+module IptablesWeb
+  class Cli
+    class LoggedOutput < ::HighLine
+      def logger
+        @logger ||= begin
+          logfile = IptablesWeb::log_path
+          say("Open log file #{logfile}")
+          logger =::Logger.new(logfile)
+          logger.formatter = ::Logger::Formatter.new
+          logger
+        end
+      end
+
+      def reset
+        @logger = nil
+      end
+
+      def logged_say(message, log_level = Logger::INFO)
+        logger.log(log_level, message) if logger
+        say(message)
+      end
+    end
+  end
+end

data/lib/iptables_web/cli/pid_file.rb

@@ -0,0 +1,65 @@
+module IptablesWeb
+  class Cli
+    class PidFile
+
+      def initialize(pidfile_path)
+        @pidfile = pidfile_path
+      end
+
+      def create
+        raise AnotherLaunched.new("Another process with #{pid} already launched!") if another_exist?
+        logged_say("Create pidfile #{self} for pid #{Process.pid}")
+        logged_say("Grab pidfile #{self} for pid #{Process.pid} due process #{pid} is down.") if other?
+        File.open(@pidfile, 'w') do |file|
+          file.write(Process.pid)
+        end
+        pid
+      end
+
+      def delete
+        raise AnotherLaunched.new("Delete error. Another process with #{pid} already launched!") if another_exist?
+        logged_say("Delete pidfile #{self} for pid #{pid}")
+        File.unlink(@pidfile) if exist?
+      end
+
+      def pid
+        if exist?
+          File.read(@pidfile).to_i
+        else
+          0
+        end
+      end
+
+      def another_exist?
+        process_exist? && other?
+      end
+
+      def other?
+        pid > 0 && Process.pid != pid
+      end
+
+      def process_exist?
+        pid > 0 && Process.kill(0, pid)
+      rescue Errno::ESRCH
+        false
+      end
+
+      def exist?
+        ::File.exists?(@pidfile)
+      end
+
+      def to_s
+        @pidfile
+      end
+
+      class PidFileException < Exception
+      end
+
+      class AlreadyLaunched < PidFileException
+      end
+
+      class AnotherLaunched < PidFileException
+      end
+    end
+  end
+end

data/lib/iptables_web/configuration.rb

@@ -1,30 +1,20 @@
 require 'yaml'
 module IptablesWeb
-  class Configuration < Hash
-    attr_accessor :loaded
-    CONFIG_FILES = %W(#{ENV['HOME']}/.iptables-web/config.yml /etc/iptables-web/config.yml)
-    STATIC_RULES_FILES = %W(#{ENV['HOME']}/.iptables-web/static_rules /etc/iptables-web/static_rules)
-    CHECKSUM_FILE = "#{ENV['HOME']}/.iptables-web/checksum"
-
-    def initialize
-      CONFIG_FILES.each do |config|
-        puts "Load configuration from #{config}"
-        if load(config)
-          @loaded = true
-          break
+  module Configuration
+    def reload
+      if File.exists?(config_path)
+        logged_say("Load config file #{config_path}")
+        YAML.load_file(config_path).each do |method, value|
+          send("#{method}=".to_sym, value)
         end
+      else
+        logged_say("Config file #{config_path} does not exist")
       end
     end
 
-    def load(config)
-      clear
-      merge! YAML.load File.read(config) if File.exist?(config)
-    end
-
-    def self.static_rules
-      rules = STATIC_RULES_FILES.map do |file|
-        File.exist?(file) ? File.read(file) : nil
-      end.compact.join("\n").strip
+    def static_rules
+      return {} unless static_rules?
+      rules = File.read(static_rules_path)
       chains = rules.scan(/\*([a-z]+)(.*?)COMMIT/m)
       if chains && chains.size > 0
         chains.each_with_object({}) do |r, obj|
@@ -37,16 +27,148 @@ module IptablesWeb
       end
     end
 
-    def self.checksum?(checksum)
-      File.exists?(CHECKSUM_FILE) && File.read(CHECKSUM_FILE) == checksum
+    def static_rules?
+      File.exist?(static_rules_path)
+    end
+
+    def home
+      @home || ENV['HOME']
+    end
+
+    def home=(home)
+      @home = home
+    end
+
+    def dir
+      @dir ||= begin
+        if root?
+          '/var/run/iptables_web'
+        else
+          File.expand_path(File.join(home, '.iptables-web'))
+        end
+      end
+    end
+
+    def dir=(d)
+      @dir = d
+    end
+
+    def path(path)
+      File.expand_path(path, dir)
     end
 
-    def self.checksum=(checksum)
-      File.write(CHECKSUM_FILE, checksum)
+    def root?
+      Process::UID.eid == 0
+    end
+
+    #
+    def config_path
+      if root?
+        '/etc/iptables_web/config.yml'
+      else
+        path(@config_path || 'config.yml')
+      end
+    end
+
+    def config_path=(config_path)
+      @config_path = config_path
+    end
+
+    #
+    def pid_path
+      path(@pid_path || 'run.pid')
+    end
+
+    def pid_path=(pid_path)
+      @pid_path = pid_path
+    end
+
+    #
+    def log_path
+      if root?
+        '/var/log/iptables-web.log'
+      else
+        path(@log_path || 'run.log')
+      end
     end
 
-    def self.config_dir
-      File.join(ENV['HOME'], '.iptables-web')
+    def log_path=(pid_path)
+      @log_path = pid_path
+      $terminal.reset if $terminal.present? && $terminal.is_a?(Cli::LoggedOutput)
+    end
+
+    #
+    def checksum_path
+      path(@checksum_path || 'checksum')
+    end
+
+    def checksum_path=(pid_path)
+      @checksum_path = pid_path
+    end
+
+    def checksum?(checksum)
+      File.exists?(checksum_path) && File.read(checksum_path) == make_checksum(checksum)
+    end
+
+    def checksum=(checksum)
+      File.write(checksum_path, make_checksum(checksum))
+    end
+
+    def make_checksum(check_sum)
+      check_sum = check_sum.to_s
+      check_sum += Digest::MD5.file(static_rules_path).hexdigest if static_rules?
+      Digest::MD5.hexdigest(check_sum)
+    end
+
+    #
+    def static_rules_path
+      if root?
+        '/etc/iptables_web/static_rules'
+      else
+        path(@static_rules_path || 'static_rules')
+      end
+    end
+
+    def static_rules_path=(static_rules_path)
+      @static_rules_path = static_rules_path
+    end
+
+    #
+    def api_base_url
+      # raise 'api_base_url is required' unless @api_base_url
+      @api_base_url
+    end
+
+    def api_base_url=(api_base_url)
+      @api_base_url = api_base_url
+      IptablesWeb::Model::Base.api_base_url = api_base_url
+    end
+
+    def access_token
+      raise 'Access_token is required' unless @access_token
+      @access_token
+    end
+
+    def access_token=(access_token)
+      @access_token = access_token
+      IptablesWeb::Model::Base.access_token = access_token
+    end
+
+    def pid_file(&block)
+      pid_file = Cli::PidFile.new(pid_path)
+      begin
+        pid_file.create
+        block.call(pid_file)
+        pid_file.delete
+      rescue Cli::PidFile::AnotherLaunched => e
+
+        pid_file.delete
+        logged_say(e.message)
+        return
+      rescue Exception => e
+        pid_file.delete
+        raise e
+      end
     end
   end
 end

data/lib/iptables_web/iptables.rb

@@ -4,8 +4,15 @@ module IptablesWeb
     include IptablesWeb::Mixin::Sudo
 
     def restore(access_rules)
+      lines = combine(access_rules)
+      if lines.size == 0
+        logged_say('Skip restore because no rules found')
+        return
+      end
+
       temp_file = Tempfile.new('rules')
-      temp_file.write render(access_rules)
+      logged_say("Save rules to file #{temp_file.path}")
+      temp_file.write lines.join("\n")
       temp_file.rewind
       execute("/sbin/iptables-restore -c #{temp_file.path}")
     ensure
@@ -20,26 +27,37 @@ module IptablesWeb
     end
 
     def static_rules
-      IptablesWeb::Configuration.static_rules
+      IptablesWeb.static_rules
     end
 
-    def render(rules)
+    def combine(rules)
       static_rules = self.static_rules
       static_filter = static_rules.delete('filter')
+
+      filter_rules =[]
+      filter_rules = filter_rules | Array(static_filter)
+      filter_rules = filter_rules | Array(rules).map(&:to_s)
+      filter_rules.reject! { |r| r.strip.empty? }
       lines = []
-      lines << '*filter'
-      lines << ':INPUT DROP [0:0]'
-      lines << ':FORWARD ACCEPT [0:0]'
-      lines << ':OUTPUT ACCEPT [0:0]'
-      lines << static_filter.join("\n").strip if static_filter
-      lines << Array(rules).map(&:to_s).join("\n").strip
-      lines << "COMMIT\n"
+      if filter_rules.size > 0
+        lines << '*filter'
+        lines << ':INPUT DROP [0:0]'
+        lines << ':FORWARD ACCEPT [0:0]'
+        lines << ':OUTPUT ACCEPT [0:0]'
+        lines = lines | filter_rules
+        lines << "COMMIT\n"
+      end
+
       static_rules.each do |chain, sub_rules|
         lines << "*#{chain}"
         lines << sub_rules.join("\n").strip
         lines << "COMMIT\n"
       end
-      lines.join("\n")
+      lines
+    end
+
+    def render(rules)
+      combine(rules).join("\n")
     end
   end
 end

data/lib/iptables_web/model/base.rb

@@ -5,9 +5,14 @@ module IptablesWeb
   module Model
     class Base < ActiveResource::Base
       add_response_method :response
-      def self.configure(config)
-        self.site = "#{config['api_base_url']}/api"
-        headers['X-Node-Access-Token'] = config['access_token']
+      class << self
+        def api_base_url=(api_base_url)
+          self.site = "#{api_base_url}/api"
+        end
+
+        def access_token=(access_token)
+          self.headers['X-Node-Access-Token'] = access_token
+        end
       end
     end
   end

data/lib/iptables_web/model/node.rb

@@ -4,23 +4,32 @@ module IptablesWeb
       self.element_name = 'node'
       self.include_root_in_json = true
 
-      def self.handshake
+      def self.handshake(&block)
         node = find('current')
-       if node
-          yield if block_given?
-          # save node after updating
-          node.ips = []
-          ::System.get_ifaddrs.each do |interface, config|
-            next if interface.to_s.include?('lo')
-            node.ips.push({
-                interface: interface,
-                ip: config[:inet_addr],
-                netmask: config[:netmask]
-              })
+        if node
+          begin
+            block.call if block
+          rescue Exception => e
+            node.has_errors = true
+            node.report = 'Exception: ' + e.message
+            node.report << "\n"
+            node.report << 'Backtrace: ' + e.backtrace.join("\n")
+            raise e
+          ensure
+            # save node after updating
+            node.ips = []
+            ::System.get_ifaddrs.each do |interface, config|
+              next if interface.to_s.include?('lo')
+              node.ips.push({
+                  interface: interface,
+                  ip: config[:inet_addr],
+                  netmask: config[:netmask]
+                })
+            end
+            node.ips.uniq! { |ip| ip[:ip] }
+            node.hostname = `hostname -f`
+            node.save
           end
-          node.ips.uniq! { |ip| ip[:ip] }
-          node.hostname = `hostname -f`
-          node.save
         end
       end
     end

data/lib/iptables_web/version.rb

@@ -1,3 +1,3 @@
 module IptablesWeb
-  VERSION = '0.3.0'
+  VERSION = '0.3.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iptables-web
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - NikolayMurga
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-04 00:00:00.000000000 Z
+date: 2015-08-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: system-getifaddrs
@@ -84,6 +84,26 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: 1.1.1
+- !ruby/object:Gem::Dependency
+  name: lockfile
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2'
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.1.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2'
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.1.3
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -124,6 +144,12 @@ files:
 - README.md
 - bin/iptables-web
 - lib/iptables_web.rb
+- lib/iptables_web/cli.rb
+- lib/iptables_web/cli/command/install.rb
+- lib/iptables_web/cli/command/update.rb
+- lib/iptables_web/cli/import.rb
+- lib/iptables_web/cli/logged_output.rb
+- lib/iptables_web/cli/pid_file.rb
 - lib/iptables_web/configuration.rb
 - lib/iptables_web/crontab.rb
 - lib/iptables_web/iptables.rb