chef_synchronize 1.0.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 72b4321e9cf345928e25d635dac34f33686cf6c6
+  data.tar.gz: 4ecd34bd2ff2b46c35a39e20df415cd680d5f25d
+SHA512:
+  metadata.gz: 5ac32717abb2b45d076748c766b7c2e6a3bfbf43aefe273576841583380f7b88c2e377867e04db663f5a1688e03ac4fd14ea87c170866dae2e08acaf2d42b36b
+  data.tar.gz: 906c3f0d0b5a0be5fa2d9654023b90dbdd249e054cccc2d2f8d7830bbbfe48189cf79753a84c08b8ee01fde0b1d8df46e7df86b04228ce810c69ade786c6fe78

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2016 Cozy Services Ltd.
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,66 @@
+# ChefSync
+
+Sync a monolithic chef repo to a chef server.
+
+## Installation
+
+Add this line to your chef repo's Gemfile:
+
+```ruby
+gem 'chef_synchronize'
+```
+
+And then execute:
+
+	$ bundle install
+
+Or install it yourself as:
+
+	$ gem install chef_synchronize
+
+## Configuration
+
+`chef_synchronize` requires configuration to post to Slack (only required if you want
+to post to Slack) and to communicate with the Chef server via Knife and Ridley.
+
+To configure Slack, you must set the `CHEFSYNC_SLACK_WEBHOOK_URL` environment 
+variable. You can optionally also set `CHEFSYNC_SLACK_USERNAME` to set the 
+username you'd like to post to Slack under, and `CHEFSYNC_SLACK_CHANNEL` to set 
+the Slack channel.
+
+You can also optionally set `CHEFSYNC_CI_BUILD_URL` and `CHEFSYNC_COMMIT_URL` 
+environment variables. If you set both, they will appear as links in the Slack 
+post's pretext above the results of the sync.
+
+To configure Knife/Ridley, you must have a `.chef` directory in your PATH that 
+contains a `.knife.rb` config file.
+
+## Usage
+
+From within your chef repo, execute the following line to see a list of
+unsynced changes:
+
+	$ bundle exec chef_sync
+
+By default, `chef_sync` is set to dryrun mode, where `chef_sync` will tell you 
+what updates would happen without actually syncing things to the Chef server, 
+and to avoid posting to Slack. The output will be printed to the console
+regardless of whether it's set to post to Slack.
+
+	$ bundle exec chef_sync --help
+	# help menu
+	$ bundle exec chef_sync --no-dryrun
+	# runs chef_sync and actually syncs changes to Chef server
+	$ bundle exec chef_sync -p
+	# runs chef_sync and posts output to Slack in addition to in the console
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/chef_synchronize/fork )
+2. Install dependencies (`bundle install`)
+3. Create your feature branch (`git checkout -b my-new-feature`)
+4. Make your changes.
+5. Run the tests and make sure they pass (`bundle exec rspec`)
+6. Commit your changes (`git commit -am 'Add some feature'`)
+7. Push to the branch (`git push origin my-new-feature`)
+8. Create a new pull request.

data/bin/chef_sync

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+lib = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'optparse'
+require 'chef_sync'
+
+options = {
+	dryrun: true,
+	post_to_slack: false
+}
+
+OptionParser.new do |opts|
+	opts.banner = 'Usage: chef-sync [options]'
+
+	opts.on('-d', '--[no-]dryrun',
+		'Print out changes without actually syncing to chef server		(default: true)') do |d|
+			options[:dryrun] = d
+		end
+
+	opts.on('-p', '--post-to-slack',
+		'Post a summary of changes to Slack					(default: false)') do |p|
+			options[:post_to_slack] = p
+		end
+end.parse!
+
+puts ChefSync.new(options[:post_to_slack], options[:dryrun]).run

data/lib/chef_sync.rb

@@ -0,0 +1,82 @@
+#!/usr/bin/env ruby
+require 'slack/post'
+
+class ChefSync
+
+	require 'chef_sync/chef_component'
+	require 'chef_sync/chef_component/cookbook'
+	require 'chef_sync/chef_component/data_bag_item'
+	require 'chef_sync/chef_component/environment'
+	require 'chef_sync/chef_component/role'
+	require 'chef_sync/knife'
+
+	RESOURCE_TYPES = [Role, Environment, DataBagItem, Cookbook]
+
+	DRYRUN_MESSAGE = "This was a dry run. Nothing has been updated on the chef server. "
+	DEFAULT_LOG_MESSAGE = "There were no changes."
+
+	def initialize(slack=false,dryrun=true)
+		@slack = slack
+		@dryrun = dryrun
+		@summary = ""
+		@log = []
+	end
+
+	def run
+		@summary = DRYRUN_MESSAGE.dup if @dryrun
+
+		RESOURCE_TYPES.each do |resource|
+			responses = resource.changes(@dryrun)
+			@summary << "#{responses.count}/#{resource.total_resources} #{resource.resource_type}s have changed. "
+			@log += responses
+		end
+
+		@log << DEFAULT_LOG_MESSAGE if @log.empty?
+
+		self.post_to_slack if @slack
+		return @summary, @log
+	end
+
+	def post_to_slack
+		opts = { webhook_url: ENV['CHEFSYNC_SLACK_WEBHOOK_URL'] }
+		opts[:username] = ENV['CHEFSYNC_SLACK_USERNAME'] if ENV['CHEFSYNC_SLACK_USERNAME']
+		opts[:channel] = ENV['CHEFSYNC_SLACK_CHANNEL'] if ENV['CHEFSYNC_SLACK_CHANNEL']
+
+		::Slack::Post.configure( opts )
+		begin
+			::Slack::Post.post_with_attachments(self.pretext, self.slack_attachment)
+		#Assuming that a RuntimeError is due to improperly configured Slack::Post.
+		rescue RuntimeError => e
+			puts "Couldn't post to Slack: #{e}"
+		end
+	end
+
+	def slack_attachment
+		[
+			{
+				fallback: @summary,
+				fields: [
+					{
+						title: 'Summary',
+						value: @summary,
+						short: false
+					},
+					{
+						title: 'Changes',
+						value: @log.join("\n"),
+						short: false
+					}
+				]
+			}
+		]
+	end
+
+	def pretext
+		if ENV['CHEFSYNC_CI_BUILD_URL'].nil? or ENV['CHEFSYNC_COMMIT_URL'].nil?
+			return "chef-sync run triggered."
+		else
+			return "<#{ENV['CHEFSYNC_CI_BUILD_URL']}|CI build> triggered by <#{ENV['CHEFSYNC_COMMIT_URL']}|commit>."
+		end
+	end
+
+end

data/lib/chef_sync/chef_component.rb

@@ -0,0 +1,117 @@
+require 'tqdm'
+
+class ChefSync
+	class ChefComponent
+
+		CHANGE_LOG_SUMMARIES = {
+			:create => " was created.",
+			:update => " was updated."
+		}
+
+		ACTIONABLE_CHANGES = [:create, :update]
+
+		FILE_EXTENSION = ".json"
+
+		class << self; attr_reader :resource_type end
+		class << self; attr_accessor :total_resources end
+
+		attr_reader :name
+		attr_reader :change
+
+		def initialize(name:, local_knife:, remote_knife:, dryrun:)
+			@name = name
+			@name_with_extension = name + FILE_EXTENSION
+
+			@local_knife = local_knife
+			@remote_knife = remote_knife
+			@dryrun = dryrun
+
+			@change = :none
+		end
+
+		def self.each(dryrun)
+			return enum_for(:each, dryrun) unless block_given?
+
+			local_knife = self.make_local_knife
+			remote_knife = self.make_remote_knife
+
+			local_resources = self.get_local_resources(local_knife, remote_knife)
+			self.total_resources = local_resources.count
+
+			default_args = {local_knife: local_knife, remote_knife: remote_knife, dryrun: dryrun}
+			local_resources.tqdm(leave: true, desc: "Checking #{self.resource_type}s").each do |args|
+				resource = self.new(args.merge(default_args))
+				resource.sync
+				yield resource
+			end
+		end
+
+		def self.changes(dryrun)
+			return self.each(dryrun).select(&:changed?).flat_map(&:summarize_changes)
+		end
+
+		def self.get_local_resources(local_knife, remote_knife)
+			local_resources = local_knife.list
+			return local_resources.map {|resource_name| {name: resource_name}}
+		end
+
+		def self.make_local_knife
+			return ChefSync::Knife.new(self.resource_type, :local)
+		end
+
+		def self.make_remote_knife
+			return ChefSync::Knife.new(self.resource_type, :remote)
+		end
+
+		def changed?
+			return @change != :none
+		end
+
+		def actionable_change?
+			return ACTIONABLE_CHANGES.include?(@change)
+		end
+
+		def summarize_changes
+			return self.resource_path + CHANGE_LOG_SUMMARIES[@change]
+		end
+
+		def resource_path
+			return "#{self.class.resource_type}s/#{@name}"
+		end
+
+		def get_local_resource
+			return @local_knife.show(@name)
+		end
+
+		def get_remote_resource
+			return @remote_knife.show(@name)
+		end
+
+		def upload_resource
+			return @remote_knife.upload(@name_with_extension)
+		end
+
+		def compare_local_and_remote_versions
+			local_resource = self.get_local_resource
+			remote_resource = self.get_remote_resource
+
+			case
+			when remote_resource.empty?
+				@change = :create
+			when local_resource != remote_resource
+				@change = :update
+			end
+
+			return @change
+		end
+
+		def sync
+			action = self.compare_local_and_remote_versions
+			if !@dryrun and self.actionable_change?
+				self.upload_resource
+			end
+			return action
+		end
+
+	end
+end

data/lib/chef_sync/chef_component/cookbook.rb

@@ -0,0 +1,99 @@
+require 'chef'
+require 'ridley'
+require 'mixlib/versioning'
+
+Ridley::Logging.logger.level = Logger.const_get('ERROR')
+
+class ChefSync::Cookbook < ChefSync::ChefComponent
+
+	CHANGE_LOG_SUMMARIES = {
+		:create => " was created.",
+		:update => " was updated.",
+		:version_regressed => " is newer than the local version.",
+		:version_changed => " has changed without a version number increase."
+	}
+
+	FILE_CHANGE_LOG_SUMMARIES = {
+		:file_changed => " has changed.",
+		:file_missing => " does not exist locally."
+	}
+
+	@resource_type = 'cookbook'
+
+	attr_reader :file_change_log
+
+	def initialize(local_version_number:, remote_version_number:, **opts)
+		@local_version_number = Mixlib::Versioning.parse(local_version_number)
+		@remote_version_number = Mixlib::Versioning.parse(remote_version_number)
+		@file_change_log = {}
+
+		super(opts)
+	end
+
+	def self.get_local_resources(local_knife, remote_knife)
+		local_cookbooks = local_knife.list
+		remote_cookbooks = remote_knife.list
+
+		return local_cookbooks.map do |cb, local_ver|
+			{name: cb, local_version_number: local_ver, remote_version_number: remote_cookbooks[cb]}
+		end
+	end
+
+	def version_changed?
+		return @change == :version_changed
+	end
+
+	def summarize_changes
+		self.actionable_change? ? prefix = "" : prefix = "WARNING: "
+		summary = [prefix + self.resource_path + CHANGE_LOG_SUMMARIES[@change]]
+		if self.version_changed?
+			summary << @file_change_log.map {|file, file_action| file + FILE_CHANGE_LOG_SUMMARIES[file_action]}
+		end
+		return summary
+	end
+
+	def get_remote_resource
+		ridley = Ridley.from_chef_config
+		remote_cookbook = ridley.cookbook.find(@name, @remote_version_number)
+		remote_cookbook_files = Chef::CookbookVersion::COOKBOOK_SEGMENTS.collect { |d| remote_cookbook.method(d).call }.flatten
+		return remote_cookbook_files
+	end
+
+	def upload_resource
+		return @remote_knife.upload(@name, '--freeze')
+	end
+
+	def compare_cookbook_files
+		remote_cookbook_files = self.get_remote_resource
+
+		remote_cookbook_files.each do |remote_file|
+			local_file_path = "#{self.resource_path}/#{remote_file['path']}"
+			begin
+				local_file_checksum = Chef::CookbookVersion.checksum_cookbook_file(File.open(local_file_path))
+				@file_change_log[local_file_path] = :file_changed unless local_file_checksum == remote_file['checksum']
+			rescue Errno::ENOENT => e
+				@file_change_log[local_file_path] = :file_missing
+			end
+		end
+		return @file_change_log
+	end
+
+	def compare_local_and_remote_versions
+		local_ver = @local_version_number
+		remote_ver = @remote_version_number
+
+		case
+		when !@remote_version_number
+			@change = :create
+		when @local_version_number < @remote_version_number
+			@change = :version_regressed
+		when @local_version_number == @remote_version_number
+			@change = :version_changed unless self.compare_cookbook_files.empty?
+		when @local_version_number > @remote_version_number
+			@change = :update
+		end
+
+		return @change
+	end
+
+end

data/lib/chef_sync/chef_component/data_bag_item.rb

@@ -0,0 +1,35 @@
+class ChefSync::DataBagItem < ChefSync::ChefComponent
+
+	@resource_type = 'data_bag'
+
+	def initialize(data_bag:, **opts)
+		@data_bag = data_bag
+
+		super(opts)
+	end
+
+	def self.get_local_resources(local_knife, remote_knife)
+		local_data_bag_list = local_knife.list
+
+		return local_data_bag_list.flat_map do |dbag|
+			local_knife.show(dbag).map {|item| {name: item, data_bag: dbag}}
+		end
+	end
+
+	def resource_path
+		return "#{self.class.resource_type}s/#{@data_bag}/#{@name}"
+	end
+
+	def get_local_resource
+		return @local_knife.show(@data_bag, @name)
+	end
+
+	def get_remote_resource
+		return @remote_knife.show(@data_bag, @name)
+	end
+
+	def upload_resource
+		return @remote_knife.upload(@data_bag, @name_with_extension)
+	end
+
+end

data/lib/chef_sync/chef_component/environment.rb

@@ -0,0 +1,5 @@
+class ChefSync::Environment < ChefSync::ChefComponent
+
+	@resource_type = 'environment'
+
+end

data/lib/chef_sync/chef_component/role.rb

@@ -0,0 +1,5 @@
+class ChefSync::Role < ChefSync::ChefComponent
+
+	@resource_type = 'role'
+
+end

data/lib/chef_sync/knife.rb

@@ -0,0 +1,113 @@
+require 'json'
+require 'knife/api'
+
+class ChefSync
+	class Knife
+
+		#Need to extend Chef::Knife::API in this class because knife_capture is top-level.
+		extend Chef::Knife::API
+
+		attr_reader :chef_component
+		attr_reader :list_command
+		attr_reader :show_command
+		attr_reader :upload_command
+
+		def initialize(chef_component, mode)
+			@chef_component = chef_component
+			@list_command = "#{chef_component}_list".to_sym
+			@show_command = "#{chef_component}_show".to_sym
+
+			if chef_component == 'cookbook'
+				@upload_command = "#{chef_component}_upload".to_sym
+			else
+				@upload_command = "#{chef_component}_from_file".to_sym
+			end
+
+			@mode = mode
+		end
+
+		# This is the hackiest hack ever.
+		# Chef::Knife keeps a persistent option state -- if you add
+		# an option like `--local-mode` once, it will be used on
+		# _every_ future call to Chef::Knife. I would _love_ to
+		# figure out how to change this behavior (lost many hours trying),
+		# but until then, we fork a new process for `knife_capture` so
+		# that we do not taint our global state.
+		# This has to stay a class method for the same reason.
+		def self.fork_knife_capture(command, args)
+			reader, writer = IO.pipe
+
+			pid = fork do
+				reader.close
+				output, stderr, status = knife_capture(command, args)
+				Marshal.dump([output, stderr, status], writer)
+			end
+
+			writer.close
+			command_output = reader.read
+			Process.wait(pid)
+			return Marshal.load(command_output)
+		end
+
+		# This instance method exists so we can mock out Knife's output for
+		# individual instances when testing.
+		def fork_knife_capture(command, args)
+			return self.class.fork_knife_capture(command, args)
+		end
+
+		def local?
+			return @mode == :local
+		end
+
+		def parse_output(command, args, output)
+			stdout, stderr, status = output
+
+			begin
+				return JSON.parse(stdout)
+			#Assuming here that a parser error means no data was returned and there was a knife error.
+			rescue JSON::ParserError => e
+				puts "Received STDERR #{stderr} when trying to run knife_capture(#{command}, #{args})."
+				return stdout
+			end
+		end
+
+		#Helper method to parse knife cookbook list into cookbooks.
+		def format_cookbook_list_output(knife_output)
+			cookbooks = {}
+			knife_output.each do |c|
+				cb, ver = c.gsub(/\s+/m, ' ').strip.split(" ")
+				cookbooks[cb] = ver
+			end
+			return cookbooks
+		end
+
+		def capture_output(command, args)
+			args << '-fj'
+			args << '-z' if self.local?
+			knife_output = self.fork_knife_capture(command, args)
+			return self.parse_output(command, args, knife_output)
+		end
+
+		def list(*args)
+			parsed_output = self.capture_output(self.list_command, args)
+			if self.chef_component == 'cookbook'
+				parsed_output = self.format_cookbook_list_output(parsed_output)
+			end
+			return parsed_output
+		end
+
+		def show(*args)
+			return self.capture_output(self.show_command, args)
+		end
+
+		def upload(*args)
+			knife_output = self.fork_knife_capture(self.upload_command, args)
+			stdout, stderr, status = knife_output
+			unless status == 0
+				puts "Received STDERR #{stderr} when trying to run knife_capture(#{self.upload_command}, #{args})."
+				return false
+			end
+			return true
+		end
+	end
+end

data/lib/chef_sync/version.rb

@@ -0,0 +1,3 @@
+class ChefSync
+  VERSION = "1.0.7"
+end

data/spec/chef_sync/chef_component/cookbook_spec.rb

@@ -0,0 +1,117 @@
+require_relative '../../spec_helper'
+
+describe 'ChefSync::Cookbook' do
+
+	let(:local_knife) do
+		ChefSync::KnifeMock.new(ChefSync::Cookbook.resource_type, :local)
+	end
+
+	let(:remote_knife) do
+		ChefSync::KnifeMock.new(ChefSync::Cookbook.resource_type, :remote)
+	end
+
+	let(:dryrun_args) do
+		{
+			name: 'boyardee',
+			local_knife: local_knife,
+			remote_knife: remote_knife,
+			dryrun: true
+		}
+	end
+
+	let(:no_dryrun_args) {dryrun_args.merge(dryrun: false)}
+
+	context 'when the local and remote are the same version number' do
+
+		let(:args) do
+			dryrun_args.merge({local_version_number: '0.1.0', remote_version_number: '0.1.0'})
+		end
+
+		it 'has no required actions when all files are the same' do
+			cb = ChefSync::Cookbook.new(args)
+			expect(cb).to receive(:upload_resource).never
+			expect(cb).to receive(:compare_cookbook_files).and_return([])
+
+			action = cb.sync
+			expect(action).to be_a(Symbol)
+			expect(action).to eq(:none)
+		end
+
+		it 'needs to be updated when a file is different' do
+			cb = ChefSync::Cookbook.new(args)
+			expect(cb).to receive(:upload_resource).never
+			expect(cb).to receive(:compare_cookbook_files).and_return([{'spaghetti' => :file_changed}])
+
+			action = cb.sync
+			expect(action).to be_a(Symbol)
+			expect(action).to eq(:version_changed)
+		end
+
+		it 'needs to be updated when a file does not exist locally' do
+			cb = ChefSync::Cookbook.new(args)
+			expect(cb).to receive(:upload_resource).never
+			expect(cb).to receive(:compare_cookbook_files).and_return([{'meatballs' => :file_missing}])
+
+			action = cb.sync
+			expect(action).to be_a(Symbol)
+			expect(action).to eq(:version_changed)
+		end
+	end
+
+	context 'when the local version is newer' do
+
+		let(:version_args) { {local_version_number: '0.1.10', remote_version_number: '0.1.9'} }
+
+		it 'needs to be updated' do
+			cb = ChefSync::Cookbook.new(dryrun_args.merge(version_args))
+			expect(cb).to receive(:upload_resource).never
+
+			action = cb.sync
+			expect(action).to be_a(Symbol)
+			expect(action).to eq(:update)
+		end
+
+		it 'uploads the new cookbook version when not in dryrun mode' do
+			remote_knife.set_success("")
+
+			cb = ChefSync::Cookbook.new(no_dryrun_args.merge(version_args))
+			expect(cb).to receive(:upload_resource)
+			cb.sync
+		end
+	end
+
+	context 'when the local version is older' do
+		it 'returns an error message' do
+			version_args = {local_version_number: '0.1.9', remote_version_number: '0.1.10'}
+			cb = ChefSync::Cookbook.new(dryrun_args.merge(version_args))
+			expect(cb).to receive(:upload_resource).never
+
+			action = cb.sync
+			expect(action).to be_a(Symbol)
+			expect(action).to eq(:version_regressed)
+		end
+	end
+
+	context 'when the remote does not exist' do
+
+		let(:version_args) { {local_version_number: '0.1.0', remote_version_number: nil} }
+
+		it 'needs to be created' do
+			cb = ChefSync::Cookbook.new(dryrun_args.merge(version_args))
+			expect(cb).to receive(:upload_resource).never
+
+			action = cb.sync
+			expect(action).to be_a(Symbol)
+			expect(action).to eq(:create)
+		end
+
+		it 'uploads the new cookbook when not in dryrun mode' do
+			remote_knife.set_success("")
+
+			cb = ChefSync::Cookbook.new(no_dryrun_args.merge(version_args))
+			expect(cb).to receive(:upload_resource)
+			cb.sync
+		end
+	end
+
+end

data/spec/chef_sync/chef_component/data_bag_item_spec.rb

@@ -0,0 +1,25 @@
+require_relative '../../spec_helper'
+require_relative '../chef_component_shared_behaviors'
+
+describe 'ChefSync::DataBagItem' do
+
+	let(:resource_class) {ChefSync::DataBagItem}
+
+	let(:local_resource) do
+		{
+			'id': 'fake_dbag',
+			'data': {
+				'stuff': 'fake data'
+			}
+		}
+	end
+
+	let(:remote_resource) do
+		local_resource.merge({'data' => {'stuff' => 'different fake data'}})
+	end
+
+	let(:init_args) { {name: 'fake_data_bag_item', data_bag: 'fake_data_bag'} }
+
+	it_should_behave_like 'a chef resource'
+
+end

data/spec/chef_sync/chef_component/environment_spec.rb

@@ -0,0 +1,28 @@
+require_relative '../../spec_helper'
+require_relative '../chef_component_shared_behaviors'
+
+describe 'ChefSync::Environment' do
+
+	let(:resource_class) {ChefSync::Environment}
+
+	let(:local_resource) do
+		{
+			'name': 'fake_environment',
+			'default_attributes': {},
+			'override_attributes': {},
+			'json_class': 'Chef::Environment',
+			'description': 'Fake chef environment.',
+			'cookbook_versions': {},
+			'chef_type': 'environment'
+		}
+	end
+
+	let(:remote_resource) do
+		local_resource.merge({'description' => 'This is a different fake environment.'})
+	end
+
+	let(:init_args) { {name: 'fake_environment'} }
+
+	it_should_behave_like 'a chef resource'
+
+end

data/spec/chef_sync/chef_component/role_spec.rb

@@ -0,0 +1,29 @@
+require_relative '../../spec_helper'
+require_relative '../chef_component_shared_behaviors'
+
+describe 'ChefSync::Role' do
+
+	let(:resource_class) {ChefSync::Role}
+
+	let(:local_resource) do
+		{
+			'name': 'fake_role',
+			'default_attributes': {},
+			'override_attributes': {},
+			'json_class': 'Chef::Role',
+			'description': 'Fake chef role.',
+			'chef_type': 'role',
+			'run_list': [],
+			'env_run_lists': {}
+		}
+	end
+
+	let(:remote_resource) do
+		local_resource.merge({'description' => 'This is a different fake chef role.'})
+	end
+
+	let(:init_args) { {name: 'fake_role'} }
+
+	it_should_behave_like 'a chef resource'
+
+end

data/spec/chef_sync/chef_component_shared_behaviors.rb

@@ -0,0 +1,86 @@
+require_relative '../spec_helper'
+
+RSpec.shared_examples 'a chef resource' do
+
+	let(:local_knife) do
+		local_knife = ChefSync::KnifeMock.new(resource_class.resource_type, :local)
+		local_knife.set_success(local_resource)
+		local_knife
+	end
+
+	let(:remote_knife) do
+		ChefSync::KnifeMock.new(resource_class.resource_type, :remote)
+	end
+
+	let(:dryrun_args) do
+		init_args.merge({local_knife: local_knife, remote_knife: remote_knife, dryrun: true})
+	end
+
+	let(:no_dryrun_args) {dryrun_args.merge({dryrun: false})}
+
+	context 'when the local and remote are the same' do
+
+		it 'has no required action' do
+			remote_knife.set_success(local_resource)
+
+			resource = resource_class.new(dryrun_args)
+			expect(resource).to receive(:upload_resource).never
+
+			action = resource.sync
+			expect(action).to be_a(Symbol)
+			expect(action).to eq(:none)
+		end
+
+	end
+
+
+	context 'when the local and remote are different' do
+
+		it 'needs to be updated' do
+			remote_knife.set_success(remote_resource)
+
+			resource = resource_class.new(dryrun_args)
+			expect(resource).to receive(:upload_resource).never
+
+			action = resource.sync
+			expect(action).to be_a(Symbol)
+			expect(action).to eq(:update)
+		end
+
+		it 'uploads the changed resource when not in dryrun mode' do
+			remote_knife.set_success(remote_resource)
+
+			resource = resource_class.new(no_dryrun_args)
+			expect(resource).to receive(:upload_resource)
+			resource.sync
+		end
+
+	end
+
+
+	context 'when the remote does not exist' do
+
+		it 'needs to be created' do
+			error = "ERROR: The object you are looking for could not be found"
+			remote_knife.set_error(error, 100)
+
+			resource = resource_class.new(dryrun_args)
+			expect(resource).to receive(:upload_resource).never
+
+			action = resource.sync
+			expect(action).to be_a(Symbol)
+			expect(action).to eq(:create)
+		end
+
+		it 'uploads the new resource when not in dryrun mode' do
+			error = "ERROR: The object you are looking for could not be found"
+			remote_knife.set_error(error, 100)
+
+			resource = resource_class.new(no_dryrun_args)
+			expect(resource).to receive(:upload_resource)
+			resource.sync
+		end
+
+	end
+
+end

data/spec/chef_sync/chef_component_spec.rb

@@ -0,0 +1,37 @@
+require_relative '../spec_helper'
+
+describe 'ChefSync::ChefComponent' do
+
+	let(:local_knife_list) {['badger', 'mushroom', 'snake']}
+
+	let(:local_knife) do
+		local_knife = ChefSync::KnifeMock.new(ChefSync::ChefComponentMock.resource_type, :local)
+		local_knife.set_success(local_knife_list)
+		local_knife
+	end
+
+	it 'creates an array of formatted summary strings for its resources' do
+		expect(ChefSync::ChefComponentMock).to receive(:make_local_knife).and_return(local_knife)
+		expect(ChefSync::ChefComponentMock).to receive(:make_remote_knife).and_return(local_knife)
+
+		result = ChefSync::ChefComponentMock.changes(true)
+
+		expect(result.count).to eq(3)
+		expect(result.first).to include(local_knife_list.first)
+		expect(result.last).to include(local_knife_list.last)
+		expect(result).to all(include('was updated.'))
+	end
+
+	it 'creates an instance for each local resource and syncs them' do
+		expect(ChefSync::ChefComponentMock).to receive(:make_local_knife).and_return(local_knife)
+		expect(ChefSync::ChefComponentMock).to receive(:make_remote_knife).and_return(local_knife)
+
+		enum = ChefSync::ChefComponentMock.each(true)
+		resources = [enum.next, enum.next, enum.next]
+
+		expect(resources.count).to eq(3)
+		expect(resources.map(&:name)).to eq(local_knife_list)
+		expect(resources.map(&:sync_called?)).to all(be_truthy)
+	end
+
+end

data/spec/chef_sync_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe 'ChefSync' do
+
+	before(:all) do
+		ChefSync::RESOURCE_TYPES.each {|r| r.total_resources = 3}
+	end
+
+	it 'has no log when there are are no actionable changes or warnings' do
+		ChefSync::RESOURCE_TYPES.each {|r| allow(r).to receive(:changes).and_return([])}
+
+		summ = ChefSync::DRYRUN_MESSAGE.dup
+		ChefSync::RESOURCE_TYPES.each do |r|
+			summ << "#{r.changes.count}/#{r.total_resources} #{r.resource_type}s have changed. "
+		end
+
+		expect(ChefSync.new.run).to eq([summ, [ChefSync::DEFAULT_LOG_MESSAGE]])
+	end
+
+	it 'has log entries when there is a change' do
+		non_cookbooks = [ChefSync::Role, ChefSync::Environment, ChefSync::DataBagItem]
+		non_cookbooks.each {|r| allow(r).to receive(:changes).and_return([])}
+		cookbook_warning = 'cookbooks/fake_cookbook is newer than the local version.'
+		allow(ChefSync::Cookbook).to receive(:changes).and_return([cookbook_warning])
+
+		summ = ChefSync::DRYRUN_MESSAGE.dup
+		ChefSync::RESOURCE_TYPES.each do |r|
+			summ << "#{r.changes.count}/#{r.total_resources} #{r.resource_type}s have changed. "
+		end
+
+		expect(ChefSync.new.run).to eq([summ, [cookbook_warning]])
+	end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,53 @@
+require 'chef_sync'
+
+require 'json'
+require 'knife/api'
+require 'rspec'
+
+class ChefSync
+	class KnifeMock < Knife
+		
+		def set_success(hash)
+			@result = [hash.to_json, '', 0]
+		end
+
+		def set_error(err, status)
+			@result = ['', err, status]
+		end
+
+		def fork_knife_capture(command, args)
+			return @result
+		end
+
+	end
+
+
+	class ChefComponentMock < ChefComponent
+
+		@resource_type = 'fake_resource'
+
+		attr_accessor :sync_called
+
+		def initialize( *args )
+			super
+			@sync_called = false
+			@change = :update
+		end
+
+		def sync
+			@sync_called = true
+		end
+
+		def sync_called?
+			return @sync_called
+		end
+
+	end
+
+end
+
+RSpec.configure do |config|
+	config.run_all_when_everything_filtered = true
+	config.filter_run :focus
+end
+

metadata

@@ -0,0 +1,185 @@
+--- !ruby/object:Gem::Specification
+name: chef_synchronize
+version: !ruby/object:Gem::Version
+  version: 1.0.7
+platform: ruby
+authors:
+- Cozy Services Ltd.
+- Rachel King
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-03-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !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'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: ridley
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.4'
+- !ruby/object:Gem::Dependency
+  name: knife-api
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: slack-post
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: tqdm
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: mixlib-versioning
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+description: Sync a monolithic chef repo to a chef server.
+email:
+- opensource@cozy.co
+executables:
+- chef_sync
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- bin/chef_sync
+- lib/chef_sync.rb
+- lib/chef_sync/chef_component.rb
+- lib/chef_sync/chef_component/cookbook.rb
+- lib/chef_sync/chef_component/data_bag_item.rb
+- lib/chef_sync/chef_component/environment.rb
+- lib/chef_sync/chef_component/role.rb
+- lib/chef_sync/knife.rb
+- lib/chef_sync/version.rb
+- spec/chef_sync/chef_component/cookbook_spec.rb
+- spec/chef_sync/chef_component/data_bag_item_spec.rb
+- spec/chef_sync/chef_component/environment_spec.rb
+- spec/chef_sync/chef_component/role_spec.rb
+- spec/chef_sync/chef_component_shared_behaviors.rb
+- spec/chef_sync/chef_component_spec.rb
+- spec/chef_sync_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/CozyCo/chef_synchronize
+licenses:
+- MIT
+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: Sync a monolithic chef repo to a chef server.
+test_files:
+- spec/chef_sync/chef_component/cookbook_spec.rb
+- spec/chef_sync/chef_component/data_bag_item_spec.rb
+- spec/chef_sync/chef_component/environment_spec.rb
+- spec/chef_sync/chef_component/role_spec.rb
+- spec/chef_sync/chef_component_shared_behaviors.rb
+- spec/chef_sync/chef_component_spec.rb
+- spec/chef_sync_spec.rb
+- spec/spec_helper.rb