config_curator 0.0.0 → 0.0.1

data/lib/config_curator/units/component.rb

@@ -0,0 +1,76 @@
+require 'mkmf'
+
+module ConfigCurator
+
+  class Component < Unit
+
+    attr_accessor :fmode, :dmode, :owner, :group
+
+    # @see Unit#install
+    def install
+      s = super
+      return s unless s
+      install_component
+      set_mode
+      set_owner
+      true
+    end
+
+    # @see Unit#install?
+    def install?
+      s = super
+      return s unless s
+      fail InstallFailed, "No component source path specified." if source_path.nil?
+      fail InstallFailed, "No component install path specified." if destination_path.nil?
+      fail InstallFailed, "Source path does not exist: #{source}" unless Dir.exists? source_path
+      true
+    end
+
+    private
+
+    # Recursively creates the necessary directories and install the component.
+    # Any files in the install directory not in the source directory are removed.
+    # Use rsync if available.
+    def install_component
+      if command? 'rsync'
+        FileUtils.mkdir_p destination_path
+        cmd = [command?('rsync'), '-rt', '--del', "#{source_path}/", destination_path]
+        logger.debug { "Running command: #{cmd.join ' '}" }
+        system *cmd
+      else
+        FileUtils.remove_entry_secure destination_path
+        FileUtils.mkdir_p destination_path
+        FileUtils.cp_r "#{source_path}/.", destination_path, preserve: true
+      end
+    end
+
+    # Recursively sets file mode.
+    # @todo Make this more platform independent.
+    def set_mode
+      chmod = command? 'chmod'
+      find = command? 'find'
+      if chmod && find
+        {fmode: 'f', dmode: 'd'}.each do |k, v|
+          next if self.send(k).nil?
+          cmd = [find,  destination_path, '-type', v, '-exec']
+          cmd.concat [chmod, self.send(k).to_s(8), '{}', '+']
+          logger.debug { "Running command: #{cmd.join ' '}" }
+          system *cmd
+        end
+      end
+    end
+
+    # Recursively sets file owner and group.
+    # @todo Make this more platform independent.
+    def set_owner
+      return unless owner || group
+      chown = command? 'chown'
+      if chown
+        cmd = [chown, '-R', "#{owner}:#{group}", destination_path]
+        logger.debug { "Running command: #{cmd.join ' '}" }
+        system *cmd
+      end
+    end
+  end
+
+end

data/lib/config_curator/units/config_file.rb

@@ -0,0 +1,76 @@
+module ConfigCurator
+
+  class ConfigFile < Unit
+
+    attr_accessor :fmode, :owner, :group
+
+    # Will use files of the form `filename.hostname.ext` if found.
+    # @see Unit#source
+    def source
+      path = super
+      host_specific_file = search_for_host_specific_file path if path
+      if host_specific_file then return host_specific_file else return path end
+    end
+
+    # Use {#source} by default.
+    # @see Unit#destination
+    def destination
+      super
+      @destination ||= source
+    end
+
+    # @see Unit#install
+    def install
+      s = super
+      return s unless s
+      install_file
+      set_mode
+      set_owner
+      true
+    end
+
+    # @see Unit#install?
+    def install?
+      s = super
+      return s unless s
+      fail InstallFailed, "No file source path specified." if source_path.nil?
+      fail InstallFailed, "Source path does not exist: #{source}" unless File.exists? source_path
+      true
+    end
+
+    private
+
+    # Recursively creates the necessary directories and install the file.
+    def install_file
+      FileUtils.mkdir_p File.dirname(destination_path)
+      FileUtils.copy source_path, destination_path, preserve: true
+    end
+
+    # Sets file mode.
+    def set_mode
+      FileUtils.chmod fmode, destination_path unless fmode.nil?
+    end
+
+    # Sets file owner and group.
+    def set_owner
+      FileUtils.chown owner, group, destination_path
+    end
+
+    private
+
+    # Will look for files with the naming pattern `filename.hostname.ext`.
+    # @param path [String] path to the non-host-specific file
+    def search_for_host_specific_file path
+      directory = File.dirname path
+      extension = File.extname path
+      basename = File.basename path.chomp(extension)
+      if Dir.exists? directory
+        file = Dir.entries(directory).grep(/^#{basename}.#{hostname.downcase}/).first
+        File.join directory, file unless file.nil?
+      else
+        nil
+      end
+    end
+  end
+
+end

data/lib/config_curator/units/symlink.rb

@@ -0,0 +1,31 @@
+module ConfigCurator
+
+  class Symlink < Unit
+
+    # @see Unit#install
+    def install
+      s = super
+      return s unless s
+      install_symlink
+      true
+    end
+
+    # @see Unit#install?
+    def install?
+      s = super
+      return s unless s
+      fail InstallFailed, "No source file specified." if source_path.nil?
+      fail InstallFailed, "No destination specified." if destination_path.nil?
+      true
+    end
+
+    private
+
+    # Recursively creates the necessary directories and make the symlink.
+    def install_symlink
+      FileUtils.mkdir_p File.dirname(destination_path)
+      FileUtils.symlink source_path, destination_path, force: true
+    end
+  end
+
+end

data/lib/config_curator/version.rb

@@ -1,3 +1,4 @@
 module ConfigCurator
-  VERSION = '0.0.0'
+  # Config Curator version.
+  VERSION = '0.0.1'
 end

data/spec/cli_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe ConfigCurator::CLI do
+
+  subject(:cli) { ConfigCurator::CLI.new }
+
+  describe "#collection" do
+
+    it "makes a new collection" do
+      expect(cli.collection).to be_a ConfigCurator::Collection
+    end
+
+    it "sets the logger for the collection" do
+      expect(cli.collection.logger).to be cli.logger
+    end
+  end
+
+  describe "#logger" do
+
+    it "makes a new logger" do
+      expect(cli.logger).to be_a Logger
+    end
+  end
+
+  describe "#install" do
+
+    it "installs the collection" do
+      allow(File).to receive(:exists?).with('manifest.yml').and_return(true)
+      expect(cli.collection).to receive(:load_manifest).with('manifest.yml')
+      expect(cli.collection).to receive(:install).and_return(true)
+      expect(cli.install 'manifest.yml').to be true
+    end
+
+    context "when --dryrun is set" do
+
+      before(:each) { allow(cli).to receive(:options).and_return({dryrun: true}) }
+
+      it "only checks if install would succeed" do
+        allow(File).to receive(:exists?).with('manifest.yml').and_return(true)
+        expect(cli.collection).to receive(:load_manifest).with('manifest.yml')
+        expect(cli.collection).to receive(:install?).and_return(true)
+        expect(cli.collection).to_not receive(:install)
+        expect(cli.install 'manifest.yml').to be true
+      end
+    end
+
+    context "manifest not found" do
+
+      it "returns false and doesn't do anything else" do
+        allow(File).to receive(:exists?).with('manifest.yml').and_return(false)
+        expect(cli.collection).to_not receive(:install)
+        expect(cli.collection).to_not receive(:install?)
+        expect(cli.install 'manifest.yml').to be false
+      end
+
+      context "when --dryrun is set" do
+
+        before(:each) { allow(cli).to receive(:options).and_return({dryrun: true}) }
+
+        it "returns false and doesn't do anything else" do
+          allow(File).to receive(:exists?).with('manifest.yml').and_return(false)
+          expect(cli.collection).to_not receive(:install)
+          expect(cli.collection).to_not receive(:install?)
+          expect(cli.install 'manifest.yml').to be false
+        end
+      end
+    end
+  end
+end

data/spec/collection_spec.rb

@@ -0,0 +1,280 @@
+require 'spec_helper'
+
+describe ConfigCurator::Collection do
+
+  subject(:collection) { ConfigCurator::Collection.new }
+
+  describe ".new" do
+
+    it "sets the logger" do
+      logger = Logger.new(STDOUT)
+      collection = ConfigCurator::Collection.new logger: logger
+      expect(collection.logger).to be logger
+    end
+
+    it "loads the manifest" do
+      expect(YAML).to receive(:load_file).with('path')
+      ConfigCurator::Collection.new manifest_path: 'path'
+    end
+  end
+
+  describe "#logger" do
+
+    it "makes a new logger" do
+      expect(collection.logger).to be_a Logger
+    end
+  end
+
+  describe "#load_manifest" do
+
+    let(:manifest) { {root: 'tmp'} }
+
+    it "loads the manifest" do
+      path = 'path/to/manifest'
+      allow(YAML).to receive(:load_file).with(path).and_return(manifest)
+      expect(collection.load_manifest path).to eq manifest
+      expect(collection.manifest).to eq manifest
+    end
+  end
+
+  describe "#create_unit" do
+
+    subject(:unit) { collection.create_unit :unit }
+
+    it "makes a new unit" do
+      expect(unit).to be_a ConfigCurator::Unit
+    end
+
+    it "sets the unit's logger" do
+      expect(unit.logger).to be collection.logger
+    end
+
+    context "with basic attributes" do
+
+      let(:attributes) { {src: 'src', dst: 'dest'} }
+      subject(:unit) { collection.create_unit :unit, attributes: attributes }
+
+      it "sets the source" do
+        expect(unit.source).to eq 'src'
+      end
+
+      it "sets the destination" do
+        expect(unit.destination).to eq 'dest'
+      end
+    end
+
+    context "with unit specific attributes" do
+
+      let(:attributes) { {src: 'src', dst: 'dest', fmode: '0600', owner: 'username'} }
+      subject(:unit) { collection.create_unit :component, attributes: attributes }
+
+      it "sets the generic attributes" do
+        expect(unit.destination).to eq 'dest'
+        expect(unit.source).to eq 'src'
+      end
+
+      it "sets the unit specific attributes" do
+        expect(unit.fmode).to eq '0600'
+        expect(unit.owner).to eq 'username'
+      end
+    end
+
+    context "with manifest" do
+
+      let(:manifest) do
+        YAML.load <<-EOF
+          :root: /tmp
+          :defaults:
+            :fmode: '0640'
+            :dmode: '0750'
+            :owner: username
+            :group: groupname
+        EOF
+      end
+      let(:attributes) { {src: 'src', dst: 'dest', dmode: '0700'} }
+      subject(:unit) { collection.create_unit :component, attributes: attributes }
+
+      before(:each) { collection.manifest = manifest }
+
+      it "sets the unit's root path" do
+        expect(unit.options[:root]).to eq manifest[:root]
+      end
+
+      it "sets the unit specific attributes" do
+        expect(unit.dmode).to eq '0700'
+      end
+
+      it "sets attribute defaults from the manifest" do
+        expect(unit.owner).to eq 'username'
+        expect(unit.group).to eq 'groupname'
+      end
+    end
+  end
+
+  describe "#units" do
+
+    let(:types) do
+      types = ConfigCurator::Collection::UNIT_TYPES
+      types.map { |t| "#{t}s".to_sym }
+    end
+
+    context "no manifest" do
+
+      it "has a key for each supported unit type" do
+        types.each do |type|
+          expect(collection.units.key? type).to be true
+        end
+      end
+
+      it "sets each entry empty" do
+        types.each do |type|
+          expect(collection.units[type]).to be_a Array
+          expect(collection.units[type]).to be_empty
+        end
+      end
+    end
+
+    context "with manifest" do
+
+      let(:manifest) do
+        YAML.load <<-EOF
+          :defaults:
+            :dmode: '0700'
+          :components:
+            - :src: components/component_1
+              :dst: inst/component_1
+              :fmode: '0600'
+            - :src: components/component_2
+          :config_files:
+            - :src: conf_file
+        EOF
+      end
+
+      before(:each) { collection.manifest = manifest }
+
+      it "has a key for each supported unit type" do
+        types.each do |type|
+          expect(collection.units.key? type).to be true
+        end
+      end
+
+      it "sets entries for missing unit types empty" do
+        %i(units symlinks).each do |type|
+          expect(collection.units[type]).to be_empty
+        end
+      end
+
+      it "contains units" do
+        expect(collection.units[:components]).to_not be_empty
+        collection.units[:components].each do |unit|
+          expect(unit).to be_a ConfigCurator::Component
+        end
+
+        expect(collection.units[:config_files]).to_not be_empty
+        collection.units[:config_files].each do |unit|
+          expect(unit).to be_a ConfigCurator::ConfigFile
+        end
+      end
+
+      it "creates units with correct attributes" do
+        component = collection.units[:components].first
+        expect(component.source).to eq 'components/component_1'
+        expect(component.destination).to eq 'inst/component_1'
+        expect(component.fmode).to eq '0600'
+        expect(component.dmode).to eq '0700'
+      end
+    end
+  end
+
+  describe "#install" do
+
+    let(:manifest) do
+      YAML.load <<-EOF
+        :components:
+          - :src: components/component_1
+            :dst: inst/component_1
+          - :src: components/component_2
+            :dst: inst/component_2
+        :config_files:
+          - :src: conf_file
+      EOF
+    end
+
+    before(:each) { collection.manifest = manifest }
+
+    let(:units) { collection.units }
+
+    context "when #install? is true" do
+
+      it "calls #install on each unit and returns true" do
+        allow(collection).to receive(:install?).and_return(true)
+        expect(units[:components][0]).to receive(:install)
+        expect(units[:components][1]).to receive(:install)
+        expect(units[:config_files][0]).to receive(:install)
+        expect(collection.install).to be true
+      end
+    end
+
+    context "when #install? is false" do
+
+      it "does not call #install on each unit and returns false" do
+        allow(collection).to receive(:install?).and_return(false)
+        expect(units[:components][0]).to_not receive(:install)
+        expect(units[:components][1]).to_not receive(:install)
+        expect(units[:config_files][0]).to_not receive(:install)
+        expect(collection.install).to be false
+      end
+    end
+
+    context "when component install fails" do
+
+      it "stops installing and returns nil" do
+        allow(collection).to receive(:install?).and_return(true)
+        expect(units[:components][0]).to receive(:install)
+        expect(units[:components][1]).to receive(:install).and_raise ConfigCurator::Unit::InstallFailed
+        expect(units[:config_files][0]).to_not receive(:install)
+        expect(collection.install).to be nil
+      end
+    end
+  end
+
+  describe "#install?" do
+
+    let(:manifest) do
+      YAML.load <<-EOF
+        :components:
+          - :src: components/component_1
+            :dst: inst/component_1
+          - :src: components/component_2
+            :dst: inst/component_2
+        :config_files:
+          - :src: conf_file
+      EOF
+    end
+
+    before(:each) { collection.manifest = manifest }
+
+    let(:units) { collection.units }
+
+    context "when no errors" do
+
+      it "calls #install? on each unit and returns true" do
+        expect(units[:components][0]).to receive(:install?)
+        expect(units[:components][1]).to receive(:install?)
+        expect(units[:config_files][0]).to receive(:install?)
+        expect(collection.install?).to be true
+      end
+    end
+
+    context "when install error" do
+
+      it "calls #install? on each unit and returns false" do
+        allow(units[:components][0]).to receive(:install?)
+        .and_raise(ConfigCurator::Unit::InstallFailed)
+        allow(units[:components][1]).to receive(:install?)
+        allow(units[:config_files][0]).to receive(:install?)
+        expect(collection.install?).to be false
+      end
+    end
+  end
+end