trocla 0.1.2 → 0.2.0

data/lib/trocla/stores.rb

@@ -0,0 +1,39 @@
+require 'trocla/store'
+# store management
+class Trocla::Stores
+  class << self
+    def [](store)
+      stores[store.to_s.downcase]
+    end
+
+    def all
+      @all ||= Dir[ path '*' ].collect do |store|
+        File.basename(store, '.rb').downcase
+      end
+    end
+
+    def available?(store)
+      all.include?(store.to_s.downcase)
+    end
+
+    private
+    def stores
+      @@stores ||= Hash.new do |hash, store|
+        store = store.to_s.downcase
+        if File.exists?(path(store))
+          require "trocla/stores/#{store}"
+          class_name = "Trocla::Stores::#{store.capitalize}"
+          hash[store] = (eval class_name)
+        else
+          raise "Store #{store} is not supported!"
+        end
+      end
+    end
+
+    def path(store)
+      File.expand_path(
+        File.join(File.dirname(__FILE__), 'stores', "#{store}.rb")
+      )
+    end
+  end
+end

data/lib/trocla/stores/memory.rb

@@ -0,0 +1,56 @@
+# a simple in memory store just as an example
+class Trocla::Stores::Memory < Trocla::Store
+  attr_reader :memory
+  def initialize(config,trocla)
+    super(config,trocla)
+    @memory = Hash.new({})
+  end
+
+  def get(key,format)
+    unless expired?(key)
+      memory[key][format]
+    else
+      delete_all(key)
+      nil
+    end
+  end
+  def set(key,format,value,options={})
+    super(key,format,value,options)
+    set_expires(key,options['expires'])
+  end
+
+  private
+  def set_plain(key,value,options)
+    memory[key] = { 'plain' => value }
+  end
+
+  def set_format(key,format,value,options)
+    memory[key].merge!({ format => value })
+  end
+
+  def delete_all(key)
+    memory.delete(key)
+  end
+  def delete_format(key,format)
+    old_val = (h = memory[key]).delete(format)
+    h.empty? ? memory.delete(key) : memory[key] = h
+    set_expires(key,nil)
+    old_val
+  end
+  private
+  def set_expires(key,expires)
+    expires = memory[key]['_expires'] if expires.nil?
+    if expires && expires > 0
+      memory[key]['_expires'] = expires
+      memory[key]['_expires_at'] = Time.now + expires
+    else
+      memory[key].delete('_expires')
+      memory[key].delete('_expires_at')
+    end
+  end
+  def expired?(key)
+    memory.key?(key) &&
+      (a = memory[key]['_expires_at']).is_a?(Time) && \
+      (a < Time.now)
+  end
+end

data/lib/trocla/stores/moneta.rb

@@ -0,0 +1,54 @@
+# the default moneta based store
+class Trocla::Stores::Moneta < Trocla::Store
+  attr_reader :moneta
+  def initialize(config,trocla)
+    super(config,trocla)
+    require 'moneta'
+    # load expire support by default
+    adapter_options = { :expires => true }.merge(
+                          store_config['adapter_options']||{})
+    @moneta = Moneta.new(store_config['adapter'],adapter_options)
+  end
+
+  def get(key,format)
+    moneta.fetch(key, {})[format]
+  end
+
+  private
+  def set_plain(key,value,options)
+    h = { 'plain' => value }
+    mo = moneta_options(key,options)
+    if options['expires'] && options['expires'] > 0
+      h['_expires'] = options['expires']
+    else
+      # be sure that we disable the existing
+      # expires if nothing is set.
+      mo[:expires] = false
+    end
+    moneta.store(key,h,mo)
+  end
+
+  def set_format(key,format,value,options)
+    moneta.store(key,
+                 moneta.fetch(key,{}).merge({ format => value }),
+                 moneta_options(key,options))
+  end
+
+  def delete_all(key)
+    moneta.delete(key)
+  end
+  def delete_format(key,format)
+    old_val = (h = moneta.fetch(key,{})).delete(format)
+    h.empty? ? moneta.delete(key) : moneta.store(key,h,moneta_options(key,{}))
+    old_val
+  end
+  def moneta_options(key,options)
+    res = {}
+    if options.key?('expires')
+      res[:expires] = options['expires']
+    elsif e = moneta.fetch(key, {})['_expires']
+      res[:expires] = e
+    end
+    res
+  end
+end

data/lib/trocla/util.rb

@@ -15,13 +15,18 @@ class Trocla
       private
 
       def charsets
-        @charsets ||= {
-          'default'       => chars,
-          'alphanumeric'  => alphanumeric,
-          'shellsafe'     => shellsafe,
-          'windowssafe'   => windowssafe,
-          'numeric'       => numeric,
-        }
+        @charsets ||= begin
+          h = {
+            'default'      => chars,
+            'alphanumeric' => alphanumeric,
+            'shellsafe'    => shellsafe,
+            'windowssafe'  => windowssafe,
+            'numeric'      => numeric,
+            'hexadecimal'  => hexadecimal,
+            'consolesafe'  => consolesafe,
+          }
+          h.each { |k, v| h[k] = v.uniq }
+        end
       end
 
       def chars
@@ -33,8 +38,14 @@ class Trocla
       def windowssafe
         @windowssafe ||= alphanumeric + windowssafe_chars
       end
+      def consolesafe
+        @consolesafe ||= alphanumeric + consolesafe_chars
+      end
+      def hexadecimal
+        @hexadecimal ||= numeric + ('a'..'f').to_a
+      end
       def alphanumeric
-        @alphanumeric ||= ('a'..'z').to_a + ('A'..'Z').to_a + ('0'..'9').to_a
+        @alphanumeric ||= ('a'..'z').to_a + ('A'..'Z').to_a + numeric
       end
       def numeric
         @numeric ||= ('0'..'9').to_a
@@ -48,6 +59,9 @@ class Trocla
       def windowssafe_chars
         @windowssafe_chars ||= "+%/@=?_.,".split(//)
       end
+      def consolesafe_chars
+        @consolesafe_chars ||= '+.-,_'.split(//)
+      end
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,7 +1,7 @@
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'rspec'
-require 'mocha'
+require 'rspec/pending_for'
 require 'yaml'
 require 'trocla'
 
@@ -9,8 +9,219 @@ require 'trocla'
 # in ./support/ and its subdirectories.
 Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
 
-RSpec.configure do |config|
-  
+RSpec.shared_examples "encryption_basics" do
+  describe 'storing' do
+    it "random passwords" do
+      expect(@trocla.password('random1', 'plain').length).to eql(16)
+    end
+
+    it "long random passwords" do
+      expect(@trocla.set_password('random1_long','plain',4096.times.collect{|s| 'x' }.join('')).length).to eql(4096)
+    end
+  end
+
+  describe 'retrieve' do
+    it "random passwords" do
+      stored = @trocla.password('random1', 'plain')
+      retrieved = @trocla.password('random1', 'plain')
+      retrieved_again = @trocla.password('random1', 'plain')
+      expect(retrieved).to eql(stored)
+      expect(retrieved_again).to eql(stored)
+      expect(retrieved_again).to eql(retrieved)
+    end
+
+    it "encrypted passwords" do
+      @trocla.set_password('some_pass', 'plain', 'super secret')
+      expect(@trocla.get_password('some_pass', 'plain')).to eql('super secret')
+    end
+
+  end
+  describe 'deleting' do
+    it "plain" do
+      @trocla.set_password('some_pass', 'plain', 'super secret')
+      expect(@trocla.delete_password('some_pass', 'plain')).to eql('super secret')
+    end
+    it "delete formats" do
+      plain = @trocla.password('some_mysqlpass', 'plain')
+      mysql = @trocla.password('some_mysqlpass', 'mysql')
+      expect(@trocla.delete_password('some_mysqlpass', 'mysql')).to eql(mysql)
+      expect(@trocla.delete_password('some_mysqlpass', 'plain')).to eql(plain)
+      expect(@trocla.get_password('some_mysqlpass','plain')).to be_nil
+      expect(@trocla.get_password('some_mysqlpass','mysql')).to be_nil
+    end
+
+    it "all passwords" do
+      plain = @trocla.password('some_mysqlpass', 'plain')
+      mysql = @trocla.password('some_mysqlpass', 'mysql')
+      deleted = @trocla.delete_password('some_mysqlpass')
+      expect(deleted).to be_a_kind_of(Hash)
+      expect(deleted['plain']).to eql(plain)
+      expect(deleted['mysql']).to eql(mysql)
+    end
+  end
+end
+RSpec.shared_examples "verify_encryption" do
+  it "does not store plaintext passwords" do
+    @trocla.set_password('noplain', 'plain', 'plaintext_password')
+    expect(File.readlines(trocla_yaml_file).grep(/plaintext_password/)).to be_empty
+  end
+
+  it "makes sure identical passwords do not match when stored" do
+    @trocla.set_password('one_key', 'plain', 'super secret')
+    @trocla.set_password('another_key', 'plain', 'super secret')
+    yaml = YAML.load_file(trocla_yaml_file)
+    expect(yaml['one_key']['plain']).not_to eq(yaml['another_key']['plain'])
+  end
+end
+
+RSpec.shared_examples 'store_validation' do |store|
+  describe '.get' do
+    it { expect(store.get('some_key','plain')).to be_nil }
+  end
+  describe '.set' do
+    it 'stores nil values' do
+      store.set('some_nil_value','plain',nil)
+      expect(store.get('some_nil_value','plain')).to be_nil
+    end
+    it 'stores plain format' do
+      store.set('some_value','plain','value')
+      expect(store.get('some_value','plain')).to eql('value')
+    end
+    it 'stores other formats' do
+      store.set('some_value','foo','bla')
+      expect(store.get('some_value','foo')).to eql('bla')
+    end
+    it 'resets other formats on setting plain' do
+      store.set('some_value','foo','bla')
+      store.set('some_value','plain','value')
+      expect(store.get('some_value','plain')).to eql('value')
+      expect(store.get('some_value','foo')).to be_nil
+    end
+  end
+  describe '.delete' do
+    it { expect(store.delete('something','foo')).to be_nil }
+    it { expect(store.delete('something')).to be_empty }
+    it 'deletes the value of a format' do
+      store.set('some_value','foo','bla')
+      expect(store.delete('some_value','foo')).to eql('bla')
+      expect(store.get('some_value','foo')).to be_nil
+    end
+    it 'deletes only the value of a format' do
+      store.set('some_value','plain','value')
+      store.set('some_value','foo','bla')
+      expect(store.delete('some_value','plain')).to eql('value')
+      expect(store.get('some_value','plain')).to be_nil
+      expect(store.get('some_value','foo')).to eql('bla')
+    end
+    it 'deletes all values without a format' do
+      store.set('some_value','plain','value')
+      store.set('some_value','foo','bla')
+      hash = store.delete('some_value')
+      expect(hash).to be_a_kind_of(Hash)
+      expect(hash['plain']).to eql('value')
+      expect(hash['foo']).to eql('bla')
+      expect(store.get('some_value','plain')).to be_nil
+      expect(store.get('some_value','foo')).to be_nil
+    end
+  end
+  describe 'expiration' do
+    it 'will not return an expired key' do
+      store.set('some_expiring_value','plain','to_be_expired',{ 'expires' => 2 })
+      expect(store.get('some_expiring_value','plain')).to eql('to_be_expired')
+      sleep 3
+      expect(store.get('some_expiring_value','plain')).to be_nil
+    end
+    it 'increases expiration when setting anything for that key' do
+      store.set('some_expiring_value','plain','to_be_expired',{ 'expires' => 2 })
+      expect(store.get('some_expiring_value','plain')).to eql('to_be_expired')
+      sleep 1
+      store.set('some_expiring_value','bla','bla_to_be_expired',{ 'expires' => 3 })
+      sleep 2
+      expect(store.get('some_expiring_value','plain')).to eql('to_be_expired')
+      sleep 2
+      expect(store.get('some_expiring_value','plain')).to be_nil
+    end
+    it 'keeps expiration when setting another value' do
+      store.set('some_expiring_value','plain','to_be_expired',{ 'expires' => 2 })
+      store.set('some_expiring_value','foo','to_be_expired_foo')
+      expect(store.get('some_expiring_value','plain')).to eql('to_be_expired')
+      sleep 3
+      expect(store.get('some_expiring_value','plain')).to be_nil
+      expect(store.get('some_expiring_value','foo')).to be_nil
+    end
+    it 'setting plain clears everything including expiration' do
+      store.set('some_expiring_value','plain','to_be_expired',{ 'expires' => 2 })
+      sleep 1
+      store.set('some_expiring_value','plain','to_be_expired2')
+      expect(store.get('some_expiring_value','plain')).to eql('to_be_expired2')
+      sleep 3
+      expect(store.get('some_expiring_value','plain')).to eql('to_be_expired2')
+    end
+    it 'extends expiration when setting another value' do
+      store.set('some_expiring_value','plain','to_be_expired',{ 'expires' => 4 })
+      sleep 2
+      store.set('some_expiring_value','foo','to_be_expired_foo')
+      expect(store.get('some_expiring_value','plain')).to eql('to_be_expired')
+      sleep 3
+      expect(store.get('some_expiring_value','plain')).to eql('to_be_expired')
+      sleep 2
+      expect(store.get('some_expiring_value','plain')).to be_nil
+    end
+    it 'extends expiration when deleting a format' do
+      store.set('some_expiring_value','plain','to_be_expired',{ 'expires' => 4 })
+      store.set('some_expiring_value','foo','to_be_expired2')
+      sleep 2
+      expect(store.delete('some_expiring_value','foo')).to eql('to_be_expired2')
+      sleep 3
+      expect(store.get('some_expiring_value','plain')).to eql('to_be_expired')
+      sleep 2
+      expect(store.get('some_expiring_value','plain')).to be_nil
+    end
+    it 'keeps expiration although we\'re fetching a value' do
+      store.set('some_expiring_value','plain','to_be_expired',{ 'expires' => 3 })
+      sleep 2
+      expect(store.get('some_expiring_value','plain')).to eql('to_be_expired')
+      sleep 2
+      expect(store.get('some_expiring_value','plain')).to be_nil
+    end
+    it 'readding a value with an expiration makes it expiring in the future' do
+      store.set('some_expiring_value','plain','to_be_expired')
+      store.set('some_expiring_value','plain','to_be_expired2',{ 'expires' => 2 })
+      expect(store.get('some_expiring_value','plain')).to eql('to_be_expired2')
+      sleep 3
+      expect(store.get('some_expiring_value','plain')).to be_nil
+    end
+    it 'setting an expires of false removes expiration' do
+      store.set('some_expiring_value','plain','to_be_expired2',{ 'expires' => 2 })
+      expect(store.get('some_expiring_value','plain')).to eql('to_be_expired2')
+      store.set('some_expiring_value','plain','to_be_expired',{ 'expires' => false })
+      sleep 3
+      expect(store.get('some_expiring_value','plain')).to eql('to_be_expired')
+    end
+    it 'setting an expires of 0 removes expiration' do
+      store.set('some_expiring_value','plain','to_be_expired2',{ 'expires' => 2 })
+      expect(store.get('some_expiring_value','plain')).to eql('to_be_expired2')
+      store.set('some_expiring_value','plain','to_be_expired',{ 'expires' => 0 })
+      sleep 3
+      expect(store.get('some_expiring_value','plain')).to eql('to_be_expired')
+    end
+    it 'setting an expires of false removes expiration even if it\'s for a different format' do
+      store.set('some_expiring_value','plain','to_be_expired2',{ 'expires' => 2 })
+      expect(store.get('some_expiring_value','plain')).to eql('to_be_expired2')
+      store.set('some_expiring_value','foo','to_be_expired_foo',{ 'expires' => false })
+      sleep 3
+      expect(store.get('some_expiring_value','plain')).to eql('to_be_expired2')
+      expect(store.get('some_expiring_value','foo')).to eql('to_be_expired_foo')
+    end
+    it 'setting an expires of 0 removes expiration even if it\'s for a different format' do
+      store.set('some_expiring_value','plain','to_be_expired2',{ 'expires' => 2 })
+      expect(store.get('some_expiring_value','plain')).to eql('to_be_expired2')
+      store.set('some_expiring_value','foo','to_be_expired_foo',{ 'expires' => 0 })
+      sleep 3
+      expect(store.get('some_expiring_value','plain')).to eql('to_be_expired2')
+      expect(store.get('some_expiring_value','foo')).to eql('to_be_expired_foo')
+    end
+  end
 end
 
 def default_config
@@ -18,26 +229,30 @@ def default_config
 end
 
 def test_config
-  return @config unless @config.nil?
-  @config = default_config
-  @config.delete('adapter_options')
-  @config['adapter'] = :Memory
-  @config
+  @config ||= default_config.merge({
+    'store' => :memory,
+  })
+end
+
+def test_config_persistent
+  @config ||= default_config.merge({
+    'store_options' => {
+      'adapter'         => :YAML,
+      'adapter_options' => {
+        :file => trocla_yaml_file
+      },
+    },
+  })
 end
 
 def ssl_test_config
-  return @ssl_config unless @ssl_config.nil?
-  @ssl_config = test_config
-  @ssl_config['encryption'] = :ssl
-  @ssl_config['ssl_options'] = {
-    :private_key => data_dir('trocla.key'),
-    :public_key  => data_dir('trocla.pub')
-  }
-  @ssl_config['adapter'] = :YAML
-  @ssl_config['adapter_options'] = {
-    :file => trocla_yaml_file
-  }
-  @ssl_config
+  @ssl_config ||= test_config_persistent.merge({
+    'encryption' => :ssl,
+    'encryption_options' => {
+      :private_key => data_dir('trocla.key'),
+      :public_key  => data_dir('trocla.pub'),
+    },
+  })
 end
 
 def base_dir