chef_stash 0.1.1

data/lib/chef_stash/disk_store.rb

@@ -0,0 +1,169 @@
+# encoding: UTF-8
+#
+# Author:    Stefano Harding <riddopic@gmail.com>
+# License:   Apache License, Version 2.0
+# Copyright: (C) 2014-2015 Stefano Harding
+#
+# 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.
+#
+
+require 'tmpdir'
+
+module ChefStash
+  # Disk stashing method variable caching hash, string, array store.
+  #
+  class DiskStore
+
+    # @return [String] location of DiskStash::Cache.store
+    #
+    attr_reader :store
+
+    # Initializes a new disked backed stash hash cache store.
+    #
+    # @param path [String] location for stash store cache.
+    #
+    # @return nothing.
+    #
+    def initialize(store = file_store)
+      @store = store
+      ensure_store_directory
+    end
+
+    # Retrieves a value from the cache, if available and not expired, or yields
+    # to a block that calculates the value to be stored in the cache.
+    #
+    # @param [Object] key
+    #   The key to look up or store at.
+    #
+    # @yield yields when the value is not present.
+    #
+    # @yieldreturn [Object]
+    #   The value to store in the cache.
+    #
+    # @return [Object]
+    #   The value at the key.
+    #
+    def cache(key = nil, &code)
+      key ||= Stash.caller_name
+      @store[key.to_sym] ||= code.call
+    end
+
+    # Clear the whole stash or the value of a key
+    #
+    # @param key [Symbol, String] (optional) string or symbol
+    # representing the key to clear
+    #
+    # @return [Hash] with a key, return the value it had, without
+    # returns {}
+    #
+    def clear!(key = nil)
+      if key.nil?
+        Dir[File.join(store, '*.cache')].each do |file|
+          File.delete(file)
+        end
+      else
+        File.delete(cache_file(key)) if File.exist?(cache_file(key))
+      end
+    end
+
+    # Retrieves the value for a given key, if nothing is set,
+    # returns nil
+    #
+    # @param key [Symbol, String] representing the key
+    #
+    # @return [Hash, Array, String] value for key
+    #
+    def [](key)
+      if key.is_a? Array
+        hash = {}
+        key.each do |k|
+          hash[k] = Marshal.load(read_cache_file(k))
+        end
+        hash unless hash.empty?
+      else
+        Marshal.load(read_cache_file(key))
+      end
+    rescue Errno::ENOENT
+      nil # key hasn't been created
+    end
+
+    # Store the given value with the given key, either an an argument
+    # or block. If a previous value was set it will be overwritten
+    # with the new value.
+    #
+    # @param key [Symbol, String] representing the key
+    # @param value [Object] that represents the value (optional)
+    # @param block [&block] that returns the value to set (optional)
+    #
+    # @return nothing.
+    #
+    def []=(key, value)
+      write_cache_file(key, Marshal.dump(value))
+    end
+
+    # returns path to cache file with 'key'
+    def cache_file(key)
+      File.join(store, key.to_s + '.cache')
+    end
+
+    private #   P R O P R I E T À   P R I V A T A   divieto di accesso
+
+    # Yada...yada...
+    #
+    def file_store
+      if ChefStash::OS.windows?
+        win_friendly_path('/chef/._stash_')
+      elsif ChefStash::OS.mac?
+        File.join(File::SEPARATOR, 'var', 'tmp', '._stash')
+      else
+        File.join(File::SEPARATOR, 'var', 'lib', '._stash')
+      end
+    end
+
+    # returns windows friendly version of the provided path, ensures
+    # backslashes are used everywhere
+    #
+    def win_friendly_path(path)
+      system_drive = ENV['SYSTEMDRIVE'] ? ENV['SYSTEMDRIVE'] : ''
+      path = File.join(system_drive, path)
+      path.gsub!(File::SEPARATOR, (File::ALT_SEPARATOR || '\\'))
+    end
+
+    def write_cache_file(key, content)
+      mode = OS.windows? ? 'wb' : 'w+'
+      f = File.open(cache_file(key), mode)
+      f.flock(File::LOCK_EX)
+      f.write(content)
+      f.close
+      content
+    end
+
+    def read_cache_file(key)
+      mode = OS.windows? ? 'rb' : 'r'
+      f = File.open(cache_file(key), mode)
+      f.flock(File::LOCK_SH)
+      out = f.read
+      f.close
+      out
+    end
+
+    def read_cache_mtime(key)
+      nil unless File.exist?(cache_file(key))
+      File.mtime(cache_file(key))
+    end
+
+    def ensure_store_directory
+      Dir.mkdir(store) unless File.directory?(store)
+    end
+  end
+end

data/lib/chef_stash/memoizable.rb

@@ -0,0 +1,44 @@
+# encoding: UTF-8
+#
+# Author: Stefano Harding <riddopic@gmail.com>
+#
+# Copyright (C) 2014-2015 Stefano Harding
+#
+# 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.
+#
+
+module ChefStash
+  # Memoization is an optimization that saves the return value of a
+  # method so it doesn't need to be re-computed every time that method
+  # is called.
+  #
+  module Memoizable
+    # Create a new memoized method. To use, extend class with Memoizable,
+    # then, in initialize, call memoize
+    #
+    # @return [undefined]
+    #
+    def memoize(methods, cache = nil)
+      cache ||= ChefStash.new(store: ChefStash::DiskStore.new)
+      methods.each do |name|
+        uncached_name = "#{name}_uncached".to_sym
+        singleton_class.class_eval do
+          alias_method uncached_name, name
+          define_method(name) do |*a, &b|
+            cache.cache(name) { send uncached_name, *a, &b }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chef_stash/os.rb

@@ -0,0 +1,45 @@
+# encoding: UTF-8
+#
+# Author:    Stefano Harding <riddopic@gmail.com>
+# License:   Apache License, Version 2.0
+# Copyright: (C) 2014-2015 Stefano Harding
+#
+# 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.
+#
+
+require 'rbconfig'
+
+module ChefStash
+  # Finds out the current Operating System.
+  module OS
+    def self.windows?
+      windows = /cygwin|mswin|mingw|bccwin|wince|emx/i
+      (RbConfig::CONFIG['host_os'] =~ windows) != nil
+    end
+
+    def self.mac?
+      mac = /darwin|mac os/i
+      (RbConfig::CONFIG['host_os'] =~ mac) != nil
+    end
+
+    def self.unix?
+      unix = /solaris|bsd/i
+      (RbConfig::CONFIG['host_os'] =~ unix) != nil
+    end
+
+    def self.linux?
+      linux = /linux/i
+      (RbConfig::CONFIG['host_os'] =~ linux) != nil
+    end
+  end
+end

data/lib/chef_stash/rash.rb

@@ -0,0 +1,195 @@
+# encoding: UTF-8
+#
+# Author:    Stefano Harding <riddopic@gmail.com>
+# License:   Apache License, Version 2.0
+# Copyright: (C) 2014-2015 Stefano Harding
+#
+# 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.
+#
+
+require 'anemone'
+
+module ChefStash
+  class Rash
+    include Memoizable
+
+    # Initializes a new store object.
+    #
+    # @param [String, URI::HTTP] url
+    #   The URL to the repository to scan.
+    #
+    # @param [String] path
+    #   The path to append to the URL.
+    #
+    # @return [ChefStash]
+    #
+    def initialize(url, path)
+      memoize [:fetch]
+      @store ||= fetch(url, path)
+    end
+
+    # Retrieves a value from the cache.
+    #
+    # @param [Object] key
+    #   The key to look up.
+    #
+    # @return [Object, nil]
+    #   The value at the key, when present, or `nil`.
+    #
+    def [](key)
+      @store[key]
+    end
+    alias_method :get, :[]
+
+    # Stores a value in the cache, either an an argument or block. If a
+    # previous value was set it will be overwritten with the new value.
+    #
+    # @param [Object] key
+    #   The key to store.
+    #
+    # @param val [Object]
+    #   The value to store.
+    #
+    # @return [Object, nil]
+    #   The value at the key.
+    #
+    def []=(key, value)
+      @store[key] = value
+    end
+    alias_method :set, :[]=
+
+    # Removes a value from the cache.
+    #
+    # @param [Object] key
+    #   The key to remove.
+    #
+    # @return [Object, nil]
+    #   The value at the key, when present, or `nil`.
+    #
+    def delete(key)
+      @store.delete(key)
+    end
+
+    # return the size of the store as an integer
+    #
+    # @return [Fixnum]
+    #
+    def size
+      @store.size
+    end
+
+    # return all keys in the store as an array
+    #
+    # @return [Array<String, Symbol>] all the keys in store
+    #
+    def keys
+      @store.keys
+    end
+
+    private #   P R O P R I E T À   P R I V A T A   Vietato L'accesso
+
+    # Loads a Chef stash hash of cache stash of hash data into the hash stash
+    # key/value stach hash cache object Chef store, or create a new one.
+    #
+    # @example
+    #   rash[:av]
+    #     => {
+    #       :ini => {
+    #                :code => "200 OK",
+    #               :depth => 3,
+    #                :size => "0.0 MB",
+    #                 :key => :av,
+    #                 :md5 => "336d9da322febc949eb22ae3f47d293b",
+    #            :modified => "Mon, 16 Feb 2015 07:13:23 GMT",
+    #                :name => "AV.ini",
+    #             :referer => "http://winini.mudbox.dev/packages_3.0/AV/",
+    #       :response_time => "1 seconds 0 milliseconds",
+    #              :sha256 => "905425e1a33b0662297181c3031066d630f8241880c7001",
+    #        :content_type => "text/inifile",
+    #                 :url => "http://winini.mudbox.dev/packages_3.0/AV/AV.ini",
+    #               :utime => "Mon, 20 Apr 2015 06:33:07 GMT",
+    #             :visited => nil
+    #       },
+    #       :zip => {
+    #                :code => "200 OK",
+    #               :depth => 3,
+    #                :size => "32.6 MB",
+    #                 :key => :av,
+    #                 :md5 => "2488ceb74eb6cb5fae463c88b806ebff",
+    #            :modified => "Mon, 16 Feb 2015 07:13:29 GMT",
+    #                :name => "AV.zip",
+    #             :referer => "http://winini.mudbox.dev/packages_3.0/AV/",
+    #       :response_time => "1 seconds 0 milliseconds",
+    #              :sha256 => "f3f14ac64263fc7b091d150a1bc0867d38af57466574587",
+    #        :content_type => "application/zip",
+    #                 :url => "http://winini.mudbox.dev/packages_3.0/AV/AV.zip",
+    #               :utime => "Mon, 20 Apr 2015 06:33:08 GMT",
+    #             :visited => nil
+    #         }
+    #     }
+    #
+    # @param [URI::HTTP] url
+    #   The URL to crawl to build a Repository Hash (RASH) cache hash store.
+    #
+    # @param [String] path
+    #   A path to filter on.
+    #
+    # @return [RASH]
+    #
+    def fetch(url, path)
+      results = []
+      regex   = /#{path}\/\w+.(\w+.(ini|zip)|sha256.txt)$/i
+      options = { threads: 20, depth_limit: 3, discard_page_bodies: true }
+
+      Anemone.crawl(url, options) do |anemone|
+        anemone.on_pages_like(regex) do |page|
+          url  = page.url.to_s
+          name = File.basename(url)
+          key  = File.basename(name, '.*').downcase.to_sym
+          type = File.extname(name)[1..-1].downcase.to_sym
+
+          header   = page.headers
+          bytes    = header['content-length'].first
+          modified = header['last-modified'].first
+          created  = Time.now.utc.httpdate
+          content  = type == :ini ? 'text/inifile' : header['content-type'].first
+          size     = ChefStash::FileSize.new(bytes).to_size(:mb).to_s
+
+          results << { key => { type => {
+            code:          ChefStash::Response.code(page.code),
+            depth:         page.depth,
+            size:          size,
+            key:           key,
+            md5:           Digest::MD5.hexdigest(page.body.to_s),
+            modified:      modified,
+            name:          name,
+            referer:       page.referer.to_s,
+            response_time: page.response_time.time_humanize,
+            sha256:        OpenSSL::Digest::SHA256.new(page.body).to_s,
+            content_type:  content,
+            url:           url,
+            created:       created,
+            visited:       page.visited
+          } } }
+
+          seen_urls << { url => { modified: modified, created: created }}
+          seen_urls << { key => { type => {
+            modified: modified, created: created
+          } } }
+        end
+      end
+
+      results.reduce({}, :recursive_merge)
+    end
+  end
+end