mixlibrary-core 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b6096253f03fb8d609d330f225b53b459614f17e
+  data.tar.gz: 130c30f1b3c838b4db5717439ff10b0f5f443125
+SHA512:
+  metadata.gz: 9051a2d056ad8965e00c5a12996477d330388a233bbd41915aa3833a6b6916c196aead6f4528a0d2d4d45c39534050fc802c7110f19e74fcf16aa65a89f04011
+  data.tar.gz: 4aeced5c6efcccf30484308fa4b019470e2704ae08fbbdbb42bcd0cb83282abeb0d067b0e8bdd902d76191e219d88e9939519db6b3660c07f9234b7a387316b1

data/LICENSE.txt

@@ -0,0 +1,13 @@
+Copyright 2014 EBSCO Information Services
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.md

@@ -0,0 +1,58 @@
+# Mixlibrary-Core
+
+Wraps some provider functionality from chef into easily consumable ruby classes that do not have the extra baggage of being dependent on Chef data objects.  Node object, Environment etc.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'mixlibrary-core'
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install mixlibrary-core
+
+## Documentation
+* Uses yard to document classes and methods.  Generate docs or automatic documentation: http://www.rubydoc.info
+    *       rake doc
+
+## Usage
+
+### Windows Oriented
+
+#### Powershell Scripts
+Needed ability to execute powershell scripts and get the powershell process back.  So to execute a powershell script:
+
+```
+require 'mixlibrary/core/apps/shell'
+     
+script= <<-EOF
+    write-host "Hello 'World'"
+EOF
+
+procobj = Mixlibrary::Core::Shell.windows_script_out!(:powershell,script)
+``` 
+
+#### Batch
+Not Implemented yet
+
+### Linux Oriented
+
+
+## Contributing
+    # Run All the Tests on your platform and build the gem
+    
+    bundle exec rake
+
+
+		
+
+1. Fork it (http://github.com/<my-github-username>/mixlibrary-core/fork)
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/lib/mixlibrary/core/apps/_dependencies.rb

@@ -0,0 +1,4 @@
+#only needed for testing outside of chef executions.  Should not be called from within a Chef Run
+unless defined?(Chef::Mixin::ShellOut)
+  require 'chef'
+end

data/lib/mixlibrary/core/apps/shell.rb

@@ -0,0 +1,3 @@
+require "mixlibrary/core/apps/_dependencies"
+
+require "mixlibrary/core/shell/app"

data/lib/mixlibrary/core/apps/utilities.rb

@@ -0,0 +1,4 @@
+require "mixlibrary/core/apps/_dependencies"
+
+require 'mixlibrary/core/utilities/ruby_info'
+require "mixlibrary/core/utilities/windows_architecture_helper"

data/lib/mixlibrary/core/shell/app.rb

@@ -0,0 +1,55 @@
+#This file defines the typical entrypoint into this shell code base.  Other entrypoints can be used, but this one is currently made easiest
+#by including an apps folder at the top level and including this file to get the pieces that are needed.
+
+#Could you easily enough require the powershell.rb directly and just outright call it, sure.  But most if not all of this code should be stateless.  This
+#implies static methods should be used.  After a bunch of reading, there seems to be no real consensus on where static methods belong.  I like the idea of classes
+#but I found more people sticking these methods in the base module, which is what I am doing here.  So the way one can interpret this file is it is the base methods
+#that are exposed in its entirety for the Shell (sub-module) within this Gem.  Since everything is stateless no need to expose classes directly unless it is overwhelmingly
+#more complicated and many methods would need to be exposed (Scalability).  (We are just scripting after all....)
+
+require 'mixlibrary/core/shell/scripts/powershell'
+require "mixlibrary/core/shell/shell_call"
+
+module Mixlibrary
+  module Core
+    module Shell
+      
+      #########################
+      #Scripts
+      #########################
+      def self.windows_script_out(shellType,script, options=nil, flags=nil,desiredarchitecture=nil)
+        return run_windows_script(shellType,false,script, options, flags,desiredarchitecture)
+      end
+      
+      def self.windows_script_out!(shellType,script, options=nil, flags=nil,desiredarchitecture=nil )
+        return run_windows_script(shellType,true,script, options, flags,desiredarchitecture)
+      end
+      
+      #########################
+      #Shell Out
+      #########################
+      def self.shell_out!(command, options=nil)
+        shellclass=Shell::ShellCall.new
+        return shellclass.shell!(command, options)
+      end     
+      
+      def self.shell_out(command, options=nil)
+        shellclass=Shell::ShellCall.new
+        return shellclass.shell(command, options)
+      end
+      
+      private 
+      def self.run_windows_script(shellType, validate, script, options, flags, architecture)
+        case shellType
+        when :powershell
+          
+          obj= Shell::Scripts::Powershell.new(script, validate, options, flags,architecture)
+          return obj.orchestrate
+        
+        else
+          raise "Shell not supported.  Currently supports: :powershell for now!"
+        end
+      end
+    end
+  end
+end

data/lib/mixlibrary/core/shell/scripts/base.rb

@@ -0,0 +1,32 @@
+require "mixlibrary/core/shell/scripts/shelloutwrapper"
+
+module Mixlibrary
+  module Core
+    module Shell
+      class Scripts
+        
+        #Base class for all script classes.  Provides an Interface of sorts that all other classes must implement and also provides the base methods that would need to be implemented.
+        class Base
+        
+          #Orchestrates running the script.  Might be as simple as calling shell_out or more complicated like doing syntax validation of the script before execution 
+          def orchestrate
+            raise "Not Implemented Exception"
+          end
+          
+          protected
+                    
+          def run_command(shell_executable, flags, filename_prefix, file_extension, code,shellout_options, eval_error)
+            shellobj =Scripts::ShellOutWrapper.new(shell_executable, flags, filename_prefix, file_extension, code, shellout_options)
+        
+            if(eval_error)
+              return shellobj.run_command!
+            else
+              return shellobj.run_command
+            end  
+          end
+        end
+        
+      end
+    end
+  end
+end

data/lib/mixlibrary/core/shell/scripts/powershell.rb

@@ -0,0 +1,127 @@
+#Runs powershell scripts with the least amount of intrusion possible.  We do some syntax checking and validation that the script did not end badly, but other than that, we 
+#try to leave the executing script in the hands of the developer.
+
+require "mixlibrary/core/shell/scripts/windows_script"
+
+module Mixlibrary
+  module Core
+    module Shell
+      class Scripts
+        class Powershell < WindowsScript
+          @originalScript   =nil
+          @validate         =nil
+          @options          =nil
+          @flagoverrides    =nil
+          
+          def initialize(script, validate, options, flags, architecture = nil)
+            super(architecture)
+            @originalScript=script
+            @options = options
+            @validate=validate
+            @flagoverrides=flags
+          end
+                  
+          def orchestrate
+            #Powershell kind of sucks with syntax checking.
+            #If any part of the script syntactically fails it will exit with a clean exit code of 0
+            #So this forced our hand to call powershell twice for every script call.
+            #1 - Put passed in script in a function to see if any standard error is generated - 
+            #only will happen if syntax is incorrect since function is never called
+            #2 - Run the user script with exception wraps to guarantee some exit status
+            syntax_check()
+            return run_command(shell,flags,filename,file_extension, finalscript(), @options, @validate)
+          end
+
+          private
+          
+          EXIT_STATUS_EXCEPTION_HANDLER=  <<-EOF
+            trap [Exception]{
+              write-error -exception ($_.Exception.Message) -erroraction continue;
+              exit 1
+            }
+          EOF
+          
+          EXIT_STATUS_RESET_SCRIPT= <<-EOF 
+          $LASTEXITCODE=0
+          EOF
+          
+          #Make this set-variable call a read only.  Technically can be overridden but most of PS scripts that set this setting,
+          #usually try to set this by doing things like $ERRORACTIONPREFERENCE="Stop"
+          #Generally speaking this is the best way to handle this situation.  We will need to determine if there are many dependent scripts
+          #that depend on being able to set this setting.
+          EXIT_STATUS_INTIALIZATION= <<-EOF 
+          Set-Variable -Name ERRORACTIONPREFERENCE -Value "STOP" -Scope Script -Option "ReadOnly"
+          \#$ErrorActionPreference="STOP"
+          try{
+          EOF
+          
+          EXIT_STATUS_POST= <<-EOF 
+          }
+          catch{
+            write-error -exception ($_.Exception) -erroraction continue;
+            exit 1
+          }
+          EOF
+          
+          #Validate valid powershell was passed in.
+          def syntax_check 
+            local_script_contents=("function testme(){ \n #{@originalScript.to_s} \n} \n")
+            
+            result = run_command(shell,flags,filename,file_extension, local_script_contents, @options, false)
+            #puts result.inspect
+            if(result.stderr.length >= 1 || result.exitstatus !=0)
+              #puts "Standard Output: \n #{result.stdout}"
+              #puts "Standard Error: \n #{result.stderr}"
+              raise RuntimeError,"Did not syntactically pass the powershell check.  \n Standard out: #{result.stdout} \n Standard Error:#{result.stderr}"
+            end
+          end
+          
+          def finalscript
+            changed_script =
+              EXIT_STATUS_EXCEPTION_HANDLER +
+              EXIT_STATUS_RESET_SCRIPT +
+              EXIT_STATUS_INTIALIZATION +
+              @originalScript + 
+              EXIT_STATUS_POST
+                        
+            return changed_script
+          end
+          
+          def flags
+            flags = [
+              # Hides the copyright banner at startup.
+              "-NoLogo",
+              # Does not present an interactive prompt to the user.
+              "-NonInteractive",
+              # Does not load the Windows PowerShell profile.
+              "-NoProfile",
+              # always set the ExecutionPolicy flag
+              # see http://technet.microsoft.com/en-us/library/ee176961.aspx
+              "-ExecutionPolicy RemoteSigned",
+              # Powershell will hang if STDIN is redirected
+              # http://connect.microsoft.com/PowerShell/feedback/details/572313/powershell-exe-can-hang-if-stdin-is-redirected
+              "-InputFormat None",
+          
+              "-File"
+            ]
+            return @flagoverrides if @flagoverrides != nil
+            return flags.join(' ')
+          end  
+       
+          def shell
+            return "powershell.exe"
+          end
+        
+          def filename
+            return "tempPSchef"
+          end
+        
+          def file_extension
+            return ".ps1"
+          end
+        
+        end
+      end
+    end
+  end
+end

data/lib/mixlibrary/core/shell/scripts/shelloutwrapper.rb

@@ -0,0 +1,111 @@
+#Wraps calling shell out with any script file.  Will create the script file execute the shell out command and delete the file once complete
+
+require "mixlibrary/core/shell/shell_call"
+module Mixlibrary
+  module Core
+    module Shell
+      class Scripts
+        class ShellOutWrapper
+          @exe
+          @flags
+          @filename
+          @fileext
+          @code
+          @shellout_options
+        
+          #runtime
+          @script_file
+        
+          def initialize(exe, flags, filename, fileext, code, shellout_options)
+            @exe=exe
+            @flags=flags
+            @filename=filename
+            @fileext=fileext
+            @code=code
+            if(shellout_options==nil)
+              @shellout_options= Hash.new()
+            else
+              @shellout_options=shellout_options
+            end
+          end
+
+          public
+          #Supported options
+          #opts[:domain]
+          #opts[:password]
+          #opts[:timeout] = @new_resource.timeout || 3600
+          #opts[:returns] = @new_resource.returns if @new_resource.returns
+          #opts[:environment] = @new_resource.environment if @new_resource.environment
+          #opts[:user] = @new_resource.user if @new_resource.user
+          #opts[:group] = @new_resource.group if @new_resource.group
+          #opts[:cwd] = @new_resource.cwd if @new_resource.cwd
+          #opts[:umask] = @new_resource.umask if @new_resource.umask
+          #opts[:log_level] = :info
+          #opts[:log_tag] = @new_resource.to_s
+          #cmd = Chef::ShellOut.new("apachectl", "start", :user => 'www', :env => nil, :cwd => '/tmp')
+          #puts "#{script_file.path}"
+            
+          def run_command
+            return shellout(false)
+          end
+        
+          def run_command!
+            return shellout(true)
+          end
+
+          private
+          
+          def set_owner_and_group
+            # FileUtils itself implements a no-op if +user+ or +group+ are nil
+            # You can prove this by running FileUtils.chown(nil,nil,'/tmp/file')
+            # as an unprivileged user.
+            #puts "#{@shellout_options.inspect}"
+            ::FileUtils.chown(@shellout_options[:user], @shellout_options[:group], @script_file.path)
+          end
+        
+          def script_file
+            #puts "File name #{filename}"
+            @script_file ||= Tempfile.open([@filename, @fileext])
+          end
+        
+          def unlink_script_file
+            @script_file && @script_file.close!
+            @script_file=nil
+          end
+        
+          def create_file ()
+            #Output script to file path
+            script_file.puts(@code)
+            script_file.close
+          
+            set_owner_and_group
+          end
+      
+          def shellout(eval_error)
+            begin
+              create_file()
+      
+              shellclass=Shell::ShellCall.new
+              if(eval_error)  
+                result = shellclass.shell!("#{@exe} #{@flags} #{@script_file.path}", @shellout_options)
+                return result  
+              else
+                result = shellclass.shell("#{@exe} #{@flags} #{@script_file.path}", @shellout_options)
+                return result
+              end
+            
+            rescue  Exception => e  
+              #puts e.message  
+              #puts e.backtrace.inspect  
+              raise 
+            
+            ensure
+              unlink_script_file
+            end
+          end
+          
+        end
+      end
+    end
+  end
+end

data/lib/mixlibrary/core/shell/scripts/windows_script.rb

@@ -0,0 +1,55 @@
+#All windows scripts will inherit from here
+require "mixlibrary/core/shell/scripts/base"
+require 'mixlibrary/core/apps/utilities'
+
+module Mixlibrary
+  module Core
+    module Shell
+      class Scripts
+        class WindowsScript < Base
+        
+          protected
+          
+          @targetarchitecutre   = nil;
+          @should_override      = nil
+        
+          def initialize(architecture)
+            super()
+        
+            #The target arch is either what the machine is or passed in parameter
+            @targetarchitecutre = architecture.nil? ?   Utilities::WindowsArchitectureHelper.architecture : architecture
+            @should_override = Utilities::WindowsArchitectureHelper.wow64_architecture_override_required?(@targetarchitecutre)
+            
+            #why do we care here?  If user wants a 32bit process call the 32 bit executable?
+            if ( @targetarchitecutre == :i386 )
+              if (RubyInfo.architecture==:x86_64)
+                raise "Support for the i386 architecture from a 64-bit Ruby runtime is not supported.  Please call the specific 32 bit assembly directly" 
+              end
+            end
+          
+          end
+        
+          def run_command(shell_executable, flags, filename_prefix, file_extension, code,shellout_options, eval_error)
+            wow64_redirection_state = nil
+
+            if @should_override
+              #puts "Disabling redirection"
+              wow64_redirection_state = Utilities::WindowsArchitectureHelper.disable_wow64_file_redirection()
+            end
+          
+            begin
+              return super(shell_executable, flags, filename_prefix, file_extension, code,shellout_options, eval_error)
+            rescue
+              raise
+            ensure
+              if ! wow64_redirection_state.nil?
+                #puts "Restoring redirection"
+                Utilities::WindowsArchitectureHelper.restore_wow64_file_redirection(wow64_redirection_state)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mixlibrary/core/shell/shell_call.rb

@@ -0,0 +1,28 @@
+#We had our hand forced here.  We had to make this an instantianted class because the Ruby Include syntax does not work with entirely static methods.
+
+module Mixlibrary
+  module Core
+    module Shell
+      class ShellCall
+        include Chef::Mixin::ShellOut
+        
+        def intialize ()
+          
+        end
+      
+        def shell(command, options)
+          result = shell_out("#{command}", options)
+          return result  
+        end
+      
+        def shell!(command, options)
+          result = shell_out!("#{command}", options)
+          return result  
+        end
+      end
+      
+    end
+  end
+end
+      
+      

data/lib/mixlibrary/core/utilities/ruby_info.rb

@@ -0,0 +1,23 @@
+#Begin defining constant symbols for ruby versions
+
+module Mixlibrary
+  module Core
+    module Utilities
+      class RubyInfo
+        
+        def self.architecture
+          #x64-mingw32
+          #i386-mingw32
+          myarch = RbConfig::CONFIG["arch"]
+          if(myarch.upcase.include?("I386"))
+            return :i386
+          elsif (myarch.upcase.include?("X64"))
+            return :x86_64
+          else
+            raise "Unsupported arch found: #{myarch}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mixlibrary/core/utilities/windows_architecture_helper.rb

@@ -0,0 +1,78 @@
+require 'win32/api' if Chef::Platform.windows?
+
+module Mixlibrary
+  module Core
+    module Utilities
+      class WindowsArchitectureHelper
+      
+        #Attempts to determine if this machine is 64 bit or not in a variety of ways - using generic ruby and/or Windows specific environment variabes
+        def self.is_machine_64bit?
+          if(RubyInfo.architecture==:x86_64)
+            return true
+          end
+        
+          if(ENV.has_key?('ProgramFiles(x86)'))
+            return true;
+          end
+        
+          if(ENV.has_key?('PROCESSOR_ARCHITEW6432'))
+            return true;
+          end        
+          
+          return false;
+        end
+      
+        #returns the architecture based on if the machine is 64 bit
+        def self.architecture
+          if(is_machine_64bit?)
+            return :x86_64
+          else
+            return :i386
+          end
+        end
+      
+        #Determines if the syswow redirection needs to be disabled based on the desired architecture.
+        def self.wow64_architecture_override_required?(desired_architecture)
+          #only use case we need to disable redirection is if
+          #running as 32 bit
+          #want 64 bit
+          #On 64bit machine
+          RubyInfo.architecture==:i386 &&
+            desired_architecture == :x86_64  &&
+            is_machine_64bit?
+          
+        end
+      
+        #Disables syswow redirection
+        def self.disable_wow64_file_redirection()
+          original_redirection_state = ['0'].pack('P')
+        
+          win32_wow_64_disable_wow_64_fs_redirection =
+            ::Win32::API.new('Wow64DisableWow64FsRedirection', 'P', 'L', 'kernel32')
+
+          succeeded = win32_wow_64_disable_wow_64_fs_redirection.call(original_redirection_state)
+
+          if succeeded == 0
+            raise  "Failed to disable Wow64 file redirection"
+          end
+
+          return original_redirection_state
+        end
+
+        #Restore syswow redirection
+        def self.restore_wow64_file_redirection(original_redirection_state )
+        
+          win32_wow_64_revert_wow_64_fs_redirection =
+            ::Win32::API.new('Wow64RevertWow64FsRedirection', 'P', 'L', 'kernel32')
+
+          succeeded = win32_wow_64_revert_wow_64_fs_redirection.call(original_redirection_state)
+
+          if succeeded == 0
+            raise  "Failed to revert Wow64 file redirection"
+          end
+        end
+        
+      end
+    end
+  end
+end

data/lib/mixlibrary/core/version.rb

@@ -0,0 +1,6 @@
+module Mixlibrary
+  module Core
+    VERSION = "0.0.3"
+    NAME = "mixlibrary-core"
+  end
+end

metadata

@@ -0,0 +1,159 @@
+--- !ruby/object:Gem::Specification
+name: mixlibrary-core
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- Nicholas Carpenter
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.1'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '5.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '5.5'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: chef
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '11.16'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '11.16'
+- !ruby/object:Gem::Dependency
+  name: win32-api
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.5.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.5.1
+description: 'MixLib for creating Core libraries in ruby for automating machines.  This
+  is an abstraction away from using Chef Providers directly to give us access to the
+  lower layers of Chef implementation to meet additional use cases. '
+email:
+- ncarpenter@ebsco.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/mixlibrary/core/apps/_dependencies.rb
+- lib/mixlibrary/core/apps/shell.rb
+- lib/mixlibrary/core/apps/utilities.rb
+- lib/mixlibrary/core/shell/app.rb
+- lib/mixlibrary/core/shell/scripts/base.rb
+- lib/mixlibrary/core/shell/scripts/powershell.rb
+- lib/mixlibrary/core/shell/scripts/shelloutwrapper.rb
+- lib/mixlibrary/core/shell/scripts/windows_script.rb
+- lib/mixlibrary/core/shell/shell_call.rb
+- lib/mixlibrary/core/utilities/ruby_info.rb
+- lib/mixlibrary/core/utilities/windows_architecture_helper.rb
+- lib/mixlibrary/core/version.rb
+homepage: ''
+licenses:
+- Apache2
+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.1
+signing_key: 
+specification_version: 4
+summary: MixLib for creating Core libraries in ruby for automating machines.
+test_files: []
+has_rdoc: