deploy_couch 0.0.1

data/.gitignore

@@ -0,0 +1,2 @@
+.DS_Store
+pkg

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in deploy_couch.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,14 @@
+PATH
+  remote: .
+  specs:
+    deploy_couch (0.0.1)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  deploy_couch!

data/Rakefile

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

data/bin/deploy_couch

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+if (ARGV.length != 1)
+  puts "usage: deploy_couch 'path/to/couchdb.yml' "
+  exit(-1)
+end
+if (!File.exists?(ARGV[0]))
+  puts "file '#{ARGV[0]}' does not exist "
+  exit(-1)
+end
+
+require 'deploy_couch'
+
+config = DeployCouch::Config.create_from_file(ARGV[0])
+deploy = DeployCouch::Deploy.new(config)
+deploy.run

data/deploy_couch.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "deploy_couch/version"
+
+Gem::Specification.new do |s|
+  s.name        = "deploy_couch"
+  s.version     = DeployCouch::VERSION
+  s.authors     = ["venky/mln"]
+  s.email       = ["venkatesh.swdev@gmail.com"]
+  s.homepage    = "https://github.com/venkateshcm/deploy_couch"
+  s.summary     = "dbDeploy for couchdb"
+  s.description = "dbDeploy for couchdb"
+
+  s.rubyforge_project = "deploy_couch"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/deploy_couch/config.rb

@@ -0,0 +1,44 @@
+module DeployCouch
+  
+  class Config
+
+    def initialize(config)
+        @config = config
+    end
+  
+    def self.create_from_file(config_file)
+        config = YAML.load_file(config_file)
+        config = config.merge("config_folder_path" => File.dirname(config_file))
+        Config.new(config)
+    end
+  
+    def hostname
+      @config["hostname"]
+    end
+  
+    def port
+      @config["port"]
+    end 
+  
+    def delta_path
+      @config["config_folder_path"] + "/" + @config["delta_path"]
+    end
+
+    def database
+      @config["database"]
+    end
+
+    def doc_type_field
+      @config["doc_type_field"]
+    end
+
+    def type_version_field
+      @config["type_version_field"]
+    end
+  
+    def merge_config(config)
+      @config = @config.merge(config)
+    end
+  
+  end
+end

data/lib/deploy_couch/couch_db_schema.rb

@@ -0,0 +1,58 @@
+module DeployCouch
+
+  class DbSchema
+  
+    def initialize(schema,repository)
+      @schema = schema
+      @repository = repository
+    end
+   
+    def self.load_or_create(config,repository)
+      default_schema = {"_id"=>"schema__schema_document_key__",config.doc_type_field=>"__schema__", 'applied_deltas'=>[], "type_versions"=>{}}
+      schema = repository.get_schema
+      if (schema.nil?)
+         repository.create_schema(default_schema)
+         schema = repository.get_schema
+      end
+      DbSchema.new(schema,repository)
+    end
+  
+    def applied_deltas
+      @schema["applied_deltas"]
+    end
+
+    def type_versions
+      @schema["type_versions"]
+    end
+  
+    def get_next_type_version_for(type)
+      current_version = type_versions[type]
+      current_version = 0 if current_version.nil?    
+      current_version += 1
+    end  
+
+    def type_version_field
+      @schema["type_version_field"]
+    end  
+    
+    def completed(delta)
+      @schema['applied_deltas'].push(delta.id)
+      current_type_version = @schema['type_versions'].has_key?(delta.type) ? @schema['type_versions'][delta.type] : 0
+      @schema['type_versions'][delta.type] = current_type_version + 1
+    
+      @repository.put_document(@schema)
+      @schema = @repository.get_schema
+    end
+
+    def rollback(delta)
+      @schema['applied_deltas'].delete(delta.id)
+      current_type_version = @schema['type_versions'].has_key?(delta.type) ? @schema['type_versions'][delta.type] : 0
+      @schema['type_versions'][delta.type] = current_type_version - 1
+    
+      @repository.put_document(@schema)
+      @schema = @repository.get_schema
+    end
+  
+  end
+
+end

data/lib/deploy_couch/delta.rb

@@ -0,0 +1,36 @@
+module DeployCouch
+
+  class Delta
+    def initialize(id,file_name,type,map_function,rollback_function)
+      @id=id
+      @file_name = file_name
+      @type = type
+      @map_function = map_function
+      @rollback_function = rollback_function
+    end
+
+    def id
+      @id
+    end
+
+  
+    def file_name
+      @file_name
+    end
+  
+    def type
+      @type
+    end
+  
+    def map_function
+      @map_function
+    end
+
+    def rollback_function
+      @rollback_function
+    end
+
+  
+  end
+
+end

data/lib/deploy_couch/delta_loader.rb

@@ -0,0 +1,37 @@
+module DeployCouch
+
+  class DeltaLoader
+    def initialize(deltas_folder)
+      @deltas_folder = deltas_folder
+    end
+  
+    def get_deltas
+      hash = {}
+      files = Dir["#{@deltas_folder}/*.yml"].select {|f| File.file?(f)}
+      files.each do |file|
+        file_name = File.basename(file)
+        key = file_name.split('_')[0].to_i
+        if (key == 0) 
+          e = RuntimeError.new("invalid file name #{file_name}")
+          raise e
+        end
+        if (hash.has_key?(key)) 
+          e = RuntimeError.new("duplicate key found in file #{file_name}")
+          raise e
+        end
+      
+        hash[key] = convert_to_delta(key,file) 
+      end
+      hash
+    end
+  
+    def convert_to_delta(id, file)
+      delta_config = YAML.load_file(file)
+      file_name = File.basename(file)
+      raise "#{file_name} content is not valid " if delta_config['type'].nil? or delta_config['map_function'].nil?
+      Delta.new(id,file_name,delta_config['type'],delta_config['map_function'],delta_config['rollback_function'])
+    end
+  
+  end
+
+end

data/lib/deploy_couch/delta_processor.rb

@@ -0,0 +1,60 @@
+module DeployCouch
+
+  class DeltaProcessor
+    def initialize(next_type_version,config,delta,repository)
+      @repository = repository
+      @delta = delta
+      @config = config
+      @next_type_version = next_type_version
+    end
+  
+    def apply
+      user_map_function = @delta.map_function.gsub("\"","\\\"")
+      map_function = <<-JSON
+        {
+         "map":"function(doc){if(doc.#{@config.doc_type_field}=='#{@delta.type}' && (!doc.#{@config.type_version_field}  || doc.#{@config.type_version_field} < #{@next_type_version})){new_doc = eval(uneval(doc)); var method = map(new_doc); if(method) emit(method,new_doc);}}
+        #{user_map_function}"
+        }
+      JSON
+      modify_document(map_function,@next_type_version)
+    end
+    
+    def rollback
+      user_rollback_function = @delta.rollback_function.gsub("\"","\\\"")
+      current_type_version = @next_type_version - 1
+      rollback_function = <<-JSON
+        {
+         "map":"function(doc){if(doc.#{@config.doc_type_field}=='#{@delta.type}' && (doc.#{@config.type_version_field} >= #{current_type_version})){new_doc = eval(uneval(doc)); var method = map(new_doc); if(method) emit(method,new_doc);}}
+        #{user_rollback_function}"
+        }
+      JSON
+      modify_document(rollback_function,current_type_version-1)
+    end
+    
+    
+private
+    def modify_document(function,type_version)
+      @repository.get_documents_to_modify(function) do |x|
+        update_document(x['value'],type_version) if x['key'] == 'update'
+        create_document(x['value'],type_version) if x['key'] == 'create'
+        delete_document(x['value'],type_version) if x['key'] == 'delete'
+      end
+    end
+  
+    def update_document(json_doc,type_version)
+      json_doc[@config.type_version_field] = type_version 
+      @repository.put_document(json_doc)
+    end
+    
+    def delete_document(json_doc,type_version)
+      @repository.delete_document(json_doc)
+    end
+    
+    def create_document(json_doc,type_version)
+      json_doc[@config.type_version_field] = type_version 
+      @repository.post_document(json_doc)
+    end
+    
+  end
+
+end

data/lib/deploy_couch/deploy.rb

@@ -0,0 +1,70 @@
+module DeployCouch
+
+  class Deploy
+    def initialize(config)
+      @config = config    
+    end
+  
+    def run
+      repository = Repository.new(@config)
+      delta_loader = DeltaLoader.new(@config.delta_path)
+      deltas_map = delta_loader.get_deltas
+      couch_schema = DbSchema.load_or_create(@config,repository)
+      all_delta_keys = deltas_map.keys.sort    
+      applied_deltas = couch_schema.applied_deltas.sort
+      last_applied_delta_id = 0
+      last_applied_delta_id = applied_deltas[-1] if applied_deltas.count > 0
+      delta_keys_to_apply = all_delta_keys.select {|key| key > last_applied_delta_id }
+    
+      deltas = []
+      puts "Deltas #{all_delta_keys} found"
+      puts "Already applied deltas #{applied_deltas}"
+      puts "Applying deltas #{delta_keys_to_apply}"
+      puts ""
+      puts "Start applying deltas"
+    
+      delta_keys_to_apply.each do |key|
+        delta = deltas_map[key]
+        type = couch_schema.get_next_type_version_for(delta.type)
+        DeltaProcessor.new(type,@config,delta,repository).apply
+        couch_schema.completed(delta)
+        deltas.push(delta)
+        puts "applied delta #{delta.file_name}"
+      end
+
+      puts "Finished applying deltas"
+      puts ""
+      puts "Deltas #{all_delta_keys - applied_deltas - delta_keys_to_apply} where skiped"
+    
+      deltas
+    end
+    
+    def rollback
+      repository = Repository.new(@config)
+      delta_loader = DeltaLoader.new(@config.delta_path)
+      deltas_map = delta_loader.get_deltas
+      couch_schema = DbSchema.load_or_create(@config,repository)
+      applied_deltas = couch_schema.applied_deltas.sort.reverse
+    
+      deltas = []
+      puts "Already applied deltas #{applied_deltas}"
+      puts "Rolling back deltas #{applied_deltas}"
+      puts ""
+      puts "Start rolling back deltas"
+    
+      applied_deltas.each do |key|
+        delta = deltas_map[key]
+        type = couch_schema.get_next_type_version_for(delta.type)
+        DeltaProcessor.new(type,@config,delta,repository).rollback
+        couch_schema.rollback(delta)
+        deltas.push(delta)
+        puts "rollback delta #{delta.file_name}"
+      end
+
+      puts "Finished rolling back deltas"    
+      deltas      
+    end
+  
+  end
+
+end

data/lib/deploy_couch/http_client.rb

@@ -0,0 +1,48 @@
+module DeployCouch
+
+  class Server
+    def initialize(host, port)
+      @host = host
+      @port = port 
+    end
+
+    def delete(uri, options = {:suppress_exceptions=>false})
+      request(Net::HTTP::Delete.new(uri),options)
+    end
+
+    def get(uri, options = {:suppress_exceptions=>false})
+      request(Net::HTTP::Get.new(uri),options)
+    end
+
+    def put(uri, json, options = {:suppress_exceptions=>false})
+      req = Net::HTTP::Put.new(uri)
+      req["content-type"] = "application/json"
+      req.body = json
+      request(req,options)
+    end
+
+    def post(uri, json, options = {:suppress_exceptions=>false})
+      req = Net::HTTP::Post.new(uri)
+      req["content-type"] = "application/json"
+      req.body = json
+      request(req,options)
+    end
+
+    def request(req, options)
+      res = Net::HTTP.start(@host, @port) { |http|http.request(req) }
+      isError = !res.kind_of?(Net::HTTPSuccess)
+      shouldSupress = options[:suppress_exceptions]   
+      if isError and !shouldSupress  
+        handle_error(req, res)
+      end
+      res
+    end
+
+    private
+
+    def handle_error(req, res)
+      e = RuntimeError.new("#{res.code}:#{res.message}\nMETHOD:#{req.method}\nURI:#{req.path}\n#{res.body}")
+      raise e
+    end
+  end
+end

data/lib/deploy_couch/repository.rb

@@ -0,0 +1,71 @@
+module DeployCouch
+
+  class Repository
+    PAGE_SIZE = 10
+  
+    def initialize(couch_config)
+      @config = couch_config
+    end
+  
+    def get_documents(map_function)
+      server = Server.new(@config.hostname,@config.port)
+      no_of_records = 0
+      page_no = 0
+      finish_loading_all = false
+    
+      while(!finish_loading_all)
+        response = server.post("/#{@config.database}/_temp_view?limit=#{PAGE_SIZE}&skip=#{PAGE_SIZE*page_no}",map_function)
+        json = JSON.parse(response.body)
+        json["rows"].each do |row|
+          yield row
+        end
+        page_no += 1
+        no_of_records += json["rows"].count
+        finish_loading_all = true if no_of_records >= json["total_rows"]
+      end
+    end
+
+    def get_documents_to_modify(map_function)
+      server = Server.new(@config.hostname,@config.port)
+      finish_loading_all = false
+    
+      while(!finish_loading_all)
+        response = server.post("/#{@config.database}/_temp_view?limit=#{PAGE_SIZE}",map_function)
+        json = JSON.parse(response.body)
+        json["rows"].each do |row|
+          yield row
+        end
+        finish_loading_all = json["total_rows"] <= 10
+      end
+    end
+
+  
+    def put_document(json)
+      server = Server.new(@config.hostname,@config.port)
+      server.put("/#{@config.database}/#{json['_id']}",json.to_json)
+    end
+
+    def post_document(json)
+      server = Server.new(@config.hostname,@config.port)
+      server.post("/#{@config.database}",json.to_json)
+    end
+
+
+    def delete_document(json)
+      server = Server.new(@config.hostname,@config.port)
+      server.delete("/#{@config.database}/#{json['_id']}?rev=#{json['_rev']}")
+    end
+  
+    def get_schema
+      server = Server.new(@config.hostname,@config.port)
+      res = server.get("/#{@config.database}/schema__schema_document_key__",{:suppress_exceptions=>true})
+      json = JSON.parse(res.body) if res.kind_of?(Net::HTTPSuccess)
+    end
+
+    def create_schema(json)
+      server = Server.new(@config.hostname,@config.port)
+      res = server.post("/#{@config.database}/",json.to_json)
+    end
+  end
+  
+end

data/lib/deploy_couch/version.rb

@@ -0,0 +1,3 @@
+module DeployCouch
+  VERSION = "0.0.1"
+end

data/lib/deploy_couch.rb

@@ -0,0 +1,13 @@
+require 'json'
+require 'yaml'
+require 'net/http'
+
+require 'deploy_couch/version'
+require 'deploy_couch/config'
+require 'deploy_couch/repository'
+require 'deploy_couch/delta_processor'
+require 'deploy_couch/delta_loader'
+require 'deploy_couch/delta'
+require 'deploy_couch/deploy'
+require 'deploy_couch/couch_db_schema'
+require 'deploy_couch/http_client'

data/spec/couchdb.yml

@@ -0,0 +1,6 @@
+hostname: localhost
+port: 5984
+delta_path: "integration/deltas"
+database: "test"
+doc_type_field: type
+type_version_field: type_version

data/spec/integration/config_spec.rb

@@ -0,0 +1,41 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+module DeployCouch
+  describe Config, "read couch db config" do
+    it "should load hostname from couchdb.yml" do
+      Config.create_from_file(File.dirname(__FILE__) + '/../couchdb.yml').hostname.should == "localhost"
+    end
+  
+    it "should load portnumber from couchdb.yml" do
+      Config.create_from_file(File.dirname(__FILE__) + '/../couchdb.yml').port.should == 5984
+    end
+  
+    it "should load delta path" do
+      Config.create_from_file(File.dirname(__FILE__) + '/../couchdb.yml').delta_path.should == File.dirname(__FILE__) + "/../integration/deltas"
+    end
+
+    it "should load database name" do
+      Config.create_from_file(File.dirname(__FILE__) + '/../couchdb.yml').database.should == "test"
+    end
+
+    it "should load document type field" do
+      Config.create_from_file(File.dirname(__FILE__) + '/../couchdb.yml').doc_type_field.should == "type"
+    end
+
+    it "should load type version field" do
+      Config.create_from_file(File.dirname(__FILE__) + '/../couchdb.yml').type_version_field.should == "type_version"
+    end
+
+
+    it "should merge config with passed in values" do
+      config = Config.create_from_file(File.dirname(__FILE__) + '/../couchdb.yml')
+      config.merge_config("database"=>"db")
+      config.database.should == "db"
+    end
+
+    it "should fail with an exception when config file is not found" do
+      lambda { Config.create_from_file(File.dirname(__FILE__) + '/../couchdb1.yml') }.should raise_error()
+    end
+
+  end
+end

data/spec/integration/database_populator.rb

@@ -0,0 +1,37 @@
+module DeployCouch
+  class DatabasePopulator
+    def initialize(database)
+      @database = database
+    end
+  
+    def with_type(doc_type)
+      @doc_type = doc_type
+      self
+    end
+  
+    def with_records(no_of_records)
+      @no_of_records = no_of_records
+      self
+    end
+  
+    def with_schema(schema_json)
+      @schema = schema_json
+      self
+    end
+  
+    def build
+      server = Server.new("localhost",5984)
+      res = server.get("/#{@database}/",{:suppress_exceptions=>true})
+      server.delete("/#{@database}/") if res.kind_of?(Net::HTTPSuccess)
+      server.put("/#{@database}/","")
+      (1..@no_of_records).each do |i|
+        h = {"name"=> "name_#{i}","type"=>@doc_type}
+        server.post("/#{@database}/",JSON.generate(h))
+      end
+    
+      server.post("/#{@database}/",@schema.to_json) if @schema
+    
+    end    
+  end
+
+end

data/spec/integration/delta_loader_spec.rb

@@ -0,0 +1,54 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+module DeployCouch
+  
+  describe DeltaLoader, "load all delta" do
+
+    it "should load all YAML files from the deltas folder" do
+    
+      map_function = "function map(doc) { doc.address = \"some address\"; return 'update'; }" 
+      rollback_function = "function map(doc) { delete doc.address; return 'update'; }" 
+
+      delta_loader = DeltaLoader.new(File.dirname(__FILE__)+'/deltas')
+      deltas = delta_loader.get_deltas
+      deltas.count.should == 5
+      deltas[1].file_name.should == "1_add_address_to_customer.yml"
+      deltas[1].type.should == "customer"
+      deltas[1].map_function.should == map_function
+      deltas[1].rollback_function.should == rollback_function
+    end
+  
+    it "should  raise an error when file is not in deltanumber_description format" do
+      File.new(File.dirname(__FILE__)+'/deltas/invalid_delta_file.yml','w')
+      begin
+        delta_loader = DeltaLoader.new(File.dirname(__FILE__)+'/deltas')
+        lambda { delta_loader.get_deltas }.should raise_error()
+      ensure
+        File.delete(File.dirname(__FILE__)+'/deltas/invalid_delta_file.yml')
+      end    
+    end
+  
+    it "should raise an error when two deltas have the same key" do
+      File.new(File.dirname(__FILE__)+'/deltas/11_duplicate_key.yml','w')
+      begin
+        delta_loader = DeltaLoader.new(File.dirname(__FILE__)+'/deltas')
+        lambda { delta_loader.get_deltas }.should raise_error()
+      ensure
+        File.delete(File.dirname(__FILE__)+'/deltas/11_duplicate_key.yml')
+      end    
+    
+    end
+  
+    it "should raise an error when file content does not have both type and map_function" do
+      File.new(File.dirname(__FILE__)+'/deltas/100_invalid_delta_file_content.yml','w')
+      begin
+        delta_loader = DeltaLoader.new(File.dirname(__FILE__)+'/deltas')
+        lambda { delta_loader.get_deltas }.should raise_error()
+      ensure
+        File.delete(File.dirname(__FILE__)+'/deltas/100_invalid_delta_file_content.yml')
+      end    
+    end
+  
+  end
+  
+end