confman 0.0.2

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.testconfman/
+bin/.confman
+
+# vim artifacts
+**.swp

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in confman.gemspec
+gem 'pry-debugger'
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Masahji Stewart
+
+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,27 @@
+# Confman
+
+Ruby client to access Confman Server
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'confman'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install confman
+
+## Usage
+
+      Confman.server = '<confman server>'
+      Confman.key = '<key>'
+      Confman.secret = '<secret>'
+
+      Confman.load_conf_set('somename', 'One')
+      # Assuming the presence of conf pair ('foo', 'bar')
+      Confman.somename.foo.should == 'bar'

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/confman

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+
+$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), "..", "lib")))
+
+require "confman/cli"
+
+Confman::CLI.start(ARGV)

data/config/test.yml

@@ -0,0 +1,4 @@
+confman:
+  endpoint_url: 'https://appforce.synctree.com/api/confman'
+  api_key:  'f5dcebf81236dcace1545fda8a3ede6'
+  secret:   '7O8EJXt6fMMfWy0/sQeuVX1VOk8FCwemtMgiJHQR'

data/confman.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'confman/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "confman"
+  spec.version       = Confman::VERSION
+  spec.authors       = ["Masahji Stewart"]
+  spec.email         = ["masahji@synctree.com"]
+  spec.description   = 'Confman ruby client'
+  spec.summary       = ''
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "rest-client", "~> 1"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rspec", "~> 2.6"
+  spec.add_development_dependency "rake"
+end

data/lib/confman.rb

@@ -0,0 +1,79 @@
+require "confman/version"
+require "confman/data_store"
+require "confman/api"
+require "confman/access"
+require 'logger'
+
+module Confman
+  class << self
+    attr_writer :logger
+
+    def load_conf_set(getter, conf_set_name)
+      pairs = begin
+        conf_set = Confman.api.find_by_name(conf_set_name)
+        DataStore.write(getter, conf_set_name, conf_set.pairs.to_json)
+        conf_set.pairs
+      rescue => ex
+        logger.error("load_conf_set(#{getter}, #{conf_set_name}): #{ex}")
+        logger.error(ex.backtrace[0..5].join("\n"))
+        d = DataStore.read(getter, conf_set_name)
+        raise(ex) if d.nil? || d.blank?
+        JSON.parse(d)
+      end
+
+      self.define_singleton_method(getter.to_s.to_sym) do
+        OpenStruct.new(pairs)
+      end
+    end
+
+    def api
+      @api ||= Confman::API.new
+      @api
+    end
+
+    def access
+      @access ||= Confman::Access.new(api)
+      @access
+    end
+
+    def logger
+      @logger ||= Logger.new(STDERR)
+      @logger
+    end
+
+  end # end class << self
+
+  class ConfFileNotFoundError < StandardError
+    def initialize(msg)
+      super(msg)
+    end
+  end
+
+end
+
+unless Hash.new.respond_to?(:symbolize_keys!)
+  class Hash
+    def symbolize_keys!
+      keys.each do |key|
+        self[(key.to_sym rescue key) || key] = delete(key)
+      end
+      self
+    end
+  end
+end
+
+unless nil.respond_to?(:blank?)
+  class NilClass
+    def blank?
+      true
+    end
+  end
+end
+
+unless "".respond_to?(:blank?)
+  class String
+    def blank?
+      self !~ /[^[:space:]]/
+    end
+  end
+end

data/lib/confman/access.rb

@@ -0,0 +1,107 @@
+require 'confman'
+require 'openssl'
+
+class Confman::Access
+  attr_accessor :api
+
+  def initialize(api = Confman.api)
+    self.api = api
+  end
+
+  def extract_keys(file = authorized_keys_location)
+    r = { :keys => [] } 
+    return r unless File.exists?(file)
+    File.readlines(file).each do |key|
+      key.chomp!
+      if key =~ /^#\sAM\s([^=]+)=(.*)$/
+        r[$1.to_sym] = $2
+      elsif key =~ /^ssh-/
+        r[:keys].push(key.chomp)
+      end
+    end
+    r
+  end
+
+  def save_keys(key_info, file = "#{authorized_keys_location}.#{Time.now.to_i}")
+    File.open(file, "w") do |fh|
+      key_info.each do |attribute, value|
+
+        if attribute == :manual_keys
+          key_info[attribute].each do |k|
+            fh.puts k
+          end
+
+        elsif attribute == :users
+          key_info[attribute].each do |u, keys|
+            keys.each do |k|
+              fh.puts("environment=\"AM_USER=#{u}\" #{k}")
+            end
+          end
+
+        else
+          fh.puts("# AM #{attribute}=#{value}")
+        end
+
+      end
+    end
+
+    File.chmod(0600, file)
+
+    file
+  end
+
+  def reset_keys
+    current_keys = extract_keys
+    new_keys = request_new_keys 
+
+    if new_keys[:updated_at] != current_keys[:updated_at]
+      new_keys[:manual_keys] = current_keys[:keys].reject { |key| key =~ /AM_USER/ }
+
+      new_authorized_keys_file = "#{authorized_keys_location}.#{Time.now.to_i}"
+      save_keys(new_keys, new_authorized_keys_file)
+      FileUtils.cp(new_authorized_keys_file, authorized_keys_location)
+    end
+
+  end
+
+  def authorized_keys_location
+    ssh_dir = "#{ENV["HOME"]}/.ssh"
+    FileUtils.mkdir_p(ssh_dir) unless File.exists?(ssh_dir)
+    return "#{ssh_dir}/authorized_keys"
+  end
+
+  def decrypt(encrypted_data)
+    encrypted_data = Base64.decode64(encrypted_data)
+    if encrypted_data =~ /^0A/
+      cipher = OpenSSL::Cipher::Cipher.new('aes-256-cbc')
+      cipher.decrypt
+      cipher.key = rsa.public_decrypt(encrypted_data[2, 128])
+      cipher.iv  = rsa.public_decrypt(encrypted_data[130, 128])
+      data = cipher.update(encrypted_data[258..-1])
+      data << cipher.final
+      return data
+    else
+      raise "invalid data found"
+    end
+  end
+
+  def rsa
+    @rsa ||= OpenSSL::PKey::RSA.new(File.read("#{self.api.config_dir}/.asym.key"))
+    @rsa
+  end
+
+  def request_new_keys
+    begin
+      results, response = Confman.api.request(:get, "computing_resources/access_keys", {})
+    rescue RestClient::Conflict
+      STDERR.puts("This instance has no key. Please run 'confman init' as root to reset your key for this instance")
+      return nil
+    end
+
+    results.update(JSON.parse(decrypt(results[:data])))
+    results.symbolize_keys!
+    results.delete(:data)
+    return results
+  end
+
+end

data/lib/confman/api.rb

@@ -0,0 +1,176 @@
+require 'rest_client'
+require 'ostruct'
+require 'json'
+require 'timeout'
+require 'base64'
+
+
+module Confman
+  class API
+    attr_accessor :endpoint_url
+    attr_accessor :api_key
+    attr_accessor :secret
+    attr_accessor :no_cloud
+    attr_writer :config_dir
+
+    def initialize
+      self.config_dir = "/etc/confman"
+    end
+
+    def config_dir
+      # Create the directory
+      unless Dir.exists?(@config_dir)
+        FileUtils.mkdir_p(@config_dir) 
+        File.chmod(0755, @config_dir)
+      end
+
+      @config_dir
+    end
+
+    def config_path
+      File.join(config_dir, "config.json")
+    end
+
+    def load_config(path = config_path)
+      if File.exists?(path)
+        config_hash = JSON.parse IO.read(path)
+
+        config_hash.each do |key, value|
+          send("#{key}=", value) if respond_to?("#{key}=")
+        end
+        return config_hash
+      end
+      return nil
+    end
+
+    def find_by_name(name)
+      begin
+        results = search(name: name)
+        raise RestClient::ResourceNotFound if results[:count] == 0
+        conf_set_hash = results[:results].first
+        DataStore.write(@api_key, name, conf_set_hash.to_json)
+        ConfSet.new(self, conf_set_hash)
+      rescue => ex
+        Confman.logger.error("find_by_name(#{name}): #{ex}")
+        Confman.logger.error(ex.backtrace[0..5].join("\n"))
+        if conf_set_str = DataStore.read(@api_key, name)
+          ConfSet.new(self, JSON.parse(conf_set_str))
+        else
+          raise ex
+        end
+      end
+    end
+
+    def search(query = {})
+      results, response = request(:get, "confman/sets/search", query)
+      results
+    end
+
+    def conf_sets(query = {})
+      results, response = request(:get, "confman/sets", query)
+      response
+    end
+
+    def reset_server_key!
+      results, response = Confman.api.request(:get, "computing_resources/key", {})
+      File.open("#{config_dir}/.asym.key", "w") do |fh|
+        fh.write results[:data]
+      end
+      File.chmod(0644, "#{config_dir}/.asym.key")
+    end
+
+    def request(method, path, object)
+      request_args = [{ accept: :json, content_type: :json }]
+
+      if method == :get
+        request_args.first[:params] = object
+      else
+        request_args.unshift(object.to_json)
+      end
+
+      response = resource[path].send(method, *request_args)
+      results = JSON.parse(response.to_s) if response.to_s.length > 0
+      results.symbolize_keys! if results.kind_of?(Hash)
+      return results, response
+    end
+
+    def resource
+      timestamp = Time.now.utc.to_i
+      secret_hash = Digest::MD5.hexdigest("#{secret}:#{timestamp}")
+
+      @resource ||= RestClient::Resource.new(endpoint_url, :headers => {
+        :cloud_meta => Base64.encode64(cloud_metadata.to_json).gsub(/\s+/, "")
+      })
+      @resource.options[:user] = api_key
+      @resource.options[:password] = "#{secret_hash}:#{timestamp}"
+      @resource
+    end
+
+    def cloud_metadata
+      return nil if no_cloud
+      @cloud_metadata ||= aws_metadata
+      @cloud_metadata
+    end
+
+    def aws_metadata(fields = %w(
+        ami-id availability-zone
+        instance-id instance-type
+        kernel-id local-hostname
+        mac public-hostname))
+
+      meta = {}
+      begin
+        fields.each do |key|
+          Timeout::timeout(1) do
+            begin
+              meta[key] = RestClient.get("http://169.254.169.254/latest/meta-data/#{key}").strip
+            rescue RestClient::ResourceNotFound => ex
+              Confman.logger.info("aws_metadata:#{key} #{ex}")
+            end
+          end
+        end
+      rescue => ex
+        Confman.logger.info("aws_metadata:#{ex}")
+      end
+      meta['type'] = 'aws' if meta.size > 0
+      return meta
+    end
+
+  end
+
+  class ConfSet
+    attr_reader :api
+    attr_accessor :id, :created_at, :updated_at, :name, :conf_pairs
+
+    def initialize(api, fields = {})
+      @api = api
+      fields.each do |k,v|
+        self.send("#{k}=", v) if self.respond_to?("#{k}=")
+      end
+    end
+
+    def update_pairs(pairs)
+      results, response = api.request(:put, "confman/sets/#{id}/update_pairs", conf_pairs: pairs)
+    end
+
+    def pairs
+      Hash[conf_pairs.collect { |p| p.symbolize_keys!; [p[:name], p[:value]] }]
+    end
+
+    def as_json
+      {
+        :id => id,
+        :name => name,
+        :created_at => created_at,
+        :updated_at => updated_at,
+        :conf_pairs => conf_pairs
+      }
+    end
+
+    def to_json
+      as_json.to_json
+    end
+  end
+
+end
+

data/lib/confman/cli.rb

@@ -0,0 +1,106 @@
+require 'confman'
+require 'optparse'
+
+class Confman::CLI
+  @@options = {}
+  @@opt_parser = nil
+
+  def self.start(args)
+    Confman.logger.level = 2
+
+    command = args.shift
+
+    begin
+      Confman.api.load_config
+    rescue Errno::EACCES => ex
+      Confman.logger.error("Unable to load config: #{ex}\nPlease run 'confman init' as root to continue")
+      exit
+    end
+
+    @@opt_parser = OptionParser.new do |opt|
+      opt.banner = "Usage: confman COMMAND OPTIONS"
+      opt.separator  ""
+      opt.separator  "Commands"
+      opt.separator  "     exportall -f <outputfile>: Imports all the conf sets into a file."
+      opt.separator  "     export -n <name> -f <outputfile>: Imports conf_set named 'name' into a file."
+      opt.separator  "     init -e <endpoint> -k <key>: Sets up config. Run this before querying the ConfMan server.(run as root)"
+      opt.separator  "     reset_keys: Resets authorized keys for the current user."
+      opt.separator  ""
+      opt.separator  "Options"
+
+      opt.on('-k key', String, 'ConfMan API Key') do |key|
+        @@options[:key] = key
+      end
+
+      opt.on('-e endpoint', String, 'ConfMan API Endpoint') do |ep|
+        @@options[:endpoint] = ep
+      end
+
+      opt.on('-f outputfile', String, 'Output file') do |of|
+        @@options[:outputfile] = of
+      end
+
+      opt.on('-n name', String, 'Name') do |name|
+        @@options[:name] = name
+      end
+    end
+
+    @@opt_parser.parse!(args)
+
+    if respond_to?(command)
+      send(command)
+    else
+      puts @@opt_parser
+    end
+  end
+
+
+  def self.init
+
+    config_hash = Confman.api.load_config || {}
+    config_hash.symbolize_keys!
+
+    %w(endpoint_url api_key secret).each do |c|
+
+      if @@options[c.to_sym].blank?
+        puts "Please enter your #{c}: [#{config_hash[c.to_sym]}]"
+        value = STDIN.gets.chomp
+        unless value.blank?
+          config_hash[c.to_sym] = value
+        end
+
+      else
+        config_hash[c.to_sym] = @@options[c.to_sym]
+      end
+    end
+
+    # Write to file
+    File.open Confman.api.config_path, "w" do |file|
+      file.write(config_hash.to_json)
+    end
+
+    Confman.api.load_config
+    Confman.api.reset_server_key!
+  end
+
+  def self.reset_keys
+    Confman.access.reset_keys
+  end
+
+  def self.exportall
+    out = @@options[:outputfile] ? File.open(@@options[:outputfile], "w") : STDOUT
+    out.write(Confman.api.conf_sets)
+  end
+
+  def self.export
+    out = @@options[:outputfile] ? File.open(@@options[:outputfile], "w") : STDOUT
+
+    begin
+      conf_set = Confman.api.find_by_name(@@options[:name])
+      out.write(conf_set.to_json)
+    rescue RestClient::ResourceNotFound
+      Confman.logger.error("ConfSet #{@@options[:name]} not found")
+    end
+  end
+
+end

data/lib/confman/data_store.rb

@@ -0,0 +1,36 @@
+module Confman
+  class DataStore
+    @@dir = '.confman'
+
+    def self.dir= dir
+      @@dir = dir
+    end
+
+    def self.dir
+      @@dir
+    end
+
+    def self.write(key, conf_set_name, data)
+      create_directory_if_not_present
+
+      filepath = compute_file_path(key, conf_set_name)
+      File.open filepath, "w" do |file|
+        file.write(data)
+      end
+    end
+
+    def self.read(key, conf_set_name)
+      filepath = compute_file_path(key, conf_set_name)
+      IO.read(filepath) if File.exists?(filepath)
+    end
+
+    def self.create_directory_if_not_present
+      Dir.mkdir(@@dir) unless Dir.exists?(dir)
+    end
+
+    def self.compute_file_path(key, conf_set_name)
+      "#{dir}/#{key}_#{Digest::MD5.hexdigest conf_set_name}"
+    end
+
+  end
+end

data/lib/confman/version.rb

@@ -0,0 +1,3 @@
+module Confman
+  VERSION = "0.0.2"
+end

data/spec/confman_spec.rb

@@ -0,0 +1,216 @@
+require 'confman'
+require 'yaml'
+
+describe Confman do
+  before :all do
+    DataStore.dir = '.testconfman'
+    @fake_search_results = {
+      count: 1,
+      results: [
+        {
+          name:"One",
+          notification_url:"",
+          read_permission:"public", write_permission:"public",
+          conf_pairs: [
+            { name:"foo", value:"bar" },
+            { name:"password", value:"something" }
+          ]
+        }
+      ]
+    }
+
+    @config = YAML.load(File.open(File.join("config", "#{ENV['TEST_ENV'] || 'test'}.yml")))
+    Confman.api.endpoint_url  = @config['confman']['endpoint_url']
+    Confman.api.api_key       = @config['confman']['api_key']
+    Confman.api.secret        = @config['confman']['secret']
+  end
+
+  describe :load_conf_set do
+    it 'can be loaded twice' do
+      Confman.api.should_receive(:search).and_return(@fake_search_results)
+      Confman.load_conf_set('somename', 'some_conf_set')
+      Confman.api.should_receive(:search).and_return(@fake_search_results)
+      lambda {Confman.load_conf_set('somename', 'some_conf_set')}.should_not raise_error
+      lambda {Confman.somename}.should_not raise_error
+    end
+
+    it 'creates a getter function which returns the conf_set' do
+      Confman.api.should_receive(:search).and_return(@fake_search_results)
+      Confman.load_conf_set('somename', 'some_conf_set')
+      lambda {Confman.somename}.should_not raise_error
+    end
+
+    it 'even works with symbols' do
+      Confman.api.should_receive(:search).and_return(@fake_search_results)
+      Confman.load_conf_set(:oauth, 'some_conf_set')
+      lambda {Confman.oauth}.should_not raise_error
+    end
+
+    it 'loads the data into an OpenStruct object' do
+      Confman.api.should_receive(:search).and_return(@fake_search_results)
+      Confman.load_conf_set('somename', 'One')
+      Confman.somename.class == OpenStruct
+      Confman.somename.foo.should == 'bar'
+    end
+
+    describe :not_found do
+      it 'throws an ConfSetNotFound exception when the conf_set is not found in the server' do
+        Confman.api.should_receive(:search).and_return({count: 0})
+
+        expect {Confman.load_conf_set('somename', 'non_existent_conf_set')}.to raise_error(RestClient::ResourceNotFound)
+      end
+
+      it 'throws an ConfSetNotFound exception when get_conf_set raises any kind of error' do
+        Confman.api.should_receive(:search).and_return({count: 0})
+        expect {Confman.load_conf_set('somename', 'network_error')}.to raise_error(RestClient::ResourceNotFound)
+      end
+    end
+  end
+
+  # Really an integration test - Uncomment and run it wrt your local server.
+  describe 'read:public:write:public' do
+    before :all do
+      Confman.api.should_receive(:aws_metadata).and_return({"ami-id"=>"ami-137bcf7a", "instance-id"=>"i-3be58146", "instance-type"=>"m1.small", "kernel-id"=>"aki-825ea7eb", "local-hostname"=>"ip-10-86-154-126.ec2.internal", "mac"=>"12:31:38:19:9C:90", "public-hostname"=>"ec2-107-20-165-98.compute-1.amazonaws.com"})
+      @conf_set = Confman.api.find_by_name('read:public:write:public')
+    end
+
+    it 'has a @conf_set with an id' do
+      @conf_set.id.should be_a_kind_of(Fixnum)
+    end
+
+    it 'calls a real server and retrieves the result' do
+      Confman.load_conf_set('o', 'read:public:write:public')
+      Confman.o.boolean_attribute.should == 'true'
+    end
+
+    it 'updates a confset' do
+      @conf_set.update_pairs(updated_boolean: false).should be_true
+    end
+
+    it 'cannot set a non boolean value to a boolean attribute' do
+      expect {@conf_set.update_pairs(updated_boolean: "bleh")}.to raise_error(RestClient::UnprocessableEntity)
+    end
+
+    it 'updates a confset' do
+      @conf_set.update_pairs(password_attribute: '12345').should be_true
+    end
+  end
+
+=begin
+  describe 'ravi integration tests' do
+    before :all do
+      Confman.api.endpoint_url  = "http://localhost:3000/api/confman"
+      Confman.api.api_key       = "e2a5ee9cdc6b41ef72f614cd2078c61"
+      Confman.api.secret        = "8XxvpFAuq+s99lawHi2gJ4W3fGJ0IlhJSjHUzcis"
+    end
+
+    it 'updates the confset' do
+      @conf_set = Confman.api.find_by_name('Set1')
+      @conf_set.update_pairs(foo: 'fromruby').should be_true
+    end
+
+    it 'retrieves all the confsets' do
+      conf_sets_json = Confman.api.conf_sets
+      JSON.parse(conf_sets_json).class.should == Array
+    end
+
+    describe :find_by_name do
+      it 'retrieves the confset' do
+        conf_set = Confman.api.find_by_name('Set1')
+        conf_set.name.should == 'Set1'
+      end
+
+      it 'caches the confset locally' do
+        conf_set = Confman.api.find_by_name('Set1')
+        file_path = DataStore.compute_file_path(Confman.api.api_key, 'Set1')
+        File.exists?(file_path).should == true
+      end
+
+      it 'raises ResourceNotFound if the confset is not present' do
+        expect {Confman.api.find_by_name('NonExistant')}.to raise_error(RestClient::ResourceNotFound)
+      end
+
+      it 'raises exception if endpoint is not reachable and there is no local copy' do
+        FileUtils.rm_rf(DataStore.dir, secure:true)
+        Confman.api.endpoint_url  = "http://localhost:3001/api/confman"
+        # Since resource is memoized
+        Confman.api.instance_variable_set(:@resource, nil)
+        expect {Confman.api.find_by_name('Set1')}.to raise_error(Exception)
+      end
+
+      it 'reads the confset locally in case of network errors' do
+        FileUtils.rm_rf(DataStore.dir, secure:true)
+        Confman.api.endpoint_url  = "http://localhost:3000/api/confman"
+
+        # Since resource is memoized
+        Confman.api.instance_variable_set(:@resource, nil)
+        conf_set = Confman.api.find_by_name('Set1')
+        Confman.api.endpoint_url  = "http://localhost:3001/api/confman"
+        Confman.api.instance_variable_set(:@resource, nil)
+        conf_set_dup = Confman.api.find_by_name('Set1')
+        conf_set_dup.name.should == 'Set1'
+      end
+    end
+  end
+=end
+
+
+  describe 'read:public:write:private' do
+    before :all do
+      @conf_set = Confman.api.find_by_name('read:public:write:private')
+    end
+
+    it 'has a @conf_set with an id' do
+      @conf_set.id.should be_a_kind_of(Fixnum)
+    end
+
+    it 'calls a real server and retrieves the result' do
+      Confman.load_conf_set('o', 'read:public:write:public')
+      Confman.o.boolean_attribute.should == 'true'
+    end
+
+    it 'cannot update a confset boolean' do
+      expect{@conf_set.update_pairs(updated_boolean: false)}.to raise_error(RestClient::PermissionDenied)
+    end
+
+    it 'cannot set a non boolean value to a boolean attribute' do
+      expect {@conf_set.update_pairs(updated_boolean: "bleh")}.to raise_error(RestClient::PermissionDenied)
+    end
+
+    it 'cannot update a confset password' do
+      expect {@conf_set.update_pairs(password_attribute: '12345')}.to raise_error(RestClient::PermissionDenied)
+    end
+
+  end
+
+  read_private_write_private = proc do
+    before :all do
+      @conf_set = Confman.api.find_by_name('read:private:write:private')
+    end
+
+    it 'has a @conf_set with an id' do
+      @conf_set.id.should be_a_kind_of(Fixnum)
+    end
+
+    it 'calls a real server and retrieves the result' do
+      Confman.load_conf_set('o', 'read:public:write:public')
+      Confman.o.boolean_attribute.should == 'true'
+    end
+
+    it 'updates a confset' do
+      @conf_set.update_pairs(updated_boolean: false).should be_true
+    end
+
+    it 'cannot set a non boolean value to a boolean attribute' do
+      expect {@conf_set.update_pairs(updated_boolean: "bleh")}.to raise_error(RestClient::UnprocessableEntity)
+    end
+
+    it 'updates a confset' do
+      @conf_set.update_pairs(password_attribute: '12345').should be_true
+    end
+  end
+
+  describe 'read:private:write:private', read_private_write_private
+  describe 'read:private:write:public',  read_private_write_private
+
+end

data/spec/data_store_spec.rb

@@ -0,0 +1,53 @@
+require 'confman'
+require 'fileutils'
+
+include Confman
+
+describe Confman::DataStore do
+  before :all do
+    DataStore.dir = '.testconfman'
+  end
+
+  describe :create_directory_if_not_present do
+    it 'creates the directory if not present' do
+      FileUtils.rm_rf(DataStore.dir, secure:true)
+      DataStore.create_directory_if_not_present
+      Dir.exists?(DataStore.dir).should be_true
+      Dir.rmdir(DataStore.dir) if Dir.exists?(DataStore.dir)
+    end
+  end
+
+  describe :write do
+    before :each do
+      FileUtils.rm_rf(DataStore.dir, secure:true)
+      DataStore.write('key','foo','some_content')
+    end
+
+    after :each do
+      FileUtils.rm_rf(DataStore.dir, secure:true)
+    end
+
+    it 'creates the signature file name' do
+      filename = "key_#{Digest::MD5.hexdigest 'foo'}"
+      File.exists?("#{DataStore.dir}/#{filename}").should be_true
+    end
+  end
+
+  describe :read do
+    after :each do
+      FileUtils.rm_rf(DataStore.dir, secure:true)
+    end
+
+    it 'reads back the written content' do
+      Dir.rmdir(DataStore.dir) if Dir.exists?(DataStore.dir)
+      DataStore.write(2,'foo','some_content')
+      DataStore.read(2,'foo').should == 'some_content'
+    end
+
+    it 'returns nil if the conf_set was not previously written' do
+      Dir.rmdir(DataStore.dir) if Dir.exists?(DataStore.dir)
+      DataStore.read(2,'foo').should be_nil
+    end
+
+  end
+end

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification
+name: confman
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Masahji Stewart
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Confman ruby client
+email:
+- masahji@synctree.com
+executables:
+- confman
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/confman
+- config/test.yml
+- confman.gemspec
+- lib/confman.rb
+- lib/confman/access.rb
+- lib/confman/api.rb
+- lib/confman/cli.rb
+- lib/confman/data_store.rb
+- lib/confman/version.rb
+- spec/confman_spec.rb
+- spec/data_store_spec.rb
+homepage: ''
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: ''
+test_files:
+- spec/confman_spec.rb
+- spec/data_store_spec.rb