codily 0.1.0.beta

data/lib/codily/elements/service_belongging_base.rb

@@ -0,0 +1,51 @@
+require 'fastly'
+require 'codily/elements/base'
+require 'codily/elements/service'
+
+module Codily
+  module Elements
+    class ServiceBelonggingBase < Base
+      def initialize(*)
+        super
+
+        if fastly_obj
+          service_version = root.service_version_get(fastly_obj.service_id)
+          raise "[bug?] Root#service_version_set should be called before passing fastly obj to ServiceBelonggingBase.new" unless service_version
+          @hash[:_service_name] = service_version[:name]
+          @hash[:_service_id] = service_version[:id]
+        end
+      end
+
+      def self.parent_class
+        Service
+      end
+
+      def parent_key
+        service_name
+      end
+
+      def service_id
+        @hash[:_service_id] ||= begin
+          service_version = root.service_version_get(service_name)
+          if service_version
+            service_version[:id]
+          else
+            nil
+          end
+        end
+      end
+
+      def service_name
+        @hash[:_service_name]
+      end
+
+      def key
+        [service_name, name]
+      end
+
+      def as_hash
+        @hash.reject { |k,v| k == :_service_name || k == :_service_id }
+      end
+    end
+  end
+end

data/lib/codily/elements/settings.rb

@@ -0,0 +1,27 @@
+require 'codily/elements/service_belongging_base'
+require 'codily/utils'
+
+module Codily
+  module Elements
+    class Settings < ServiceBelonggingBase
+      def setup
+        @hash = Utils.symbolize_keys(@hash)
+      end
+      def dsl_args
+        [as_hash]
+      end
+
+      def as_dsl_hash
+        {}
+      end
+
+      def key
+        service_name
+      end
+
+      def fastly_class
+        Fastly::Settings
+      end
+    end
+  end
+end

data/lib/codily/elements/vcl.rb

@@ -0,0 +1,22 @@
+require 'codily/elements/service_belongging_base'
+require 'codily/elements/file_loadable'
+
+module Codily
+  module Elements
+    class Vcl < ServiceBelonggingBase
+      include FileLoadable
+
+      def content(obj)
+        getset :content, file_loadable(obj)
+      end
+
+      def main(bool = nil)
+        getset :main, bool
+      end
+
+      def fastly_class
+        Fastly::VCL
+      end
+    end
+  end
+end

data/lib/codily/engine.rb

@@ -0,0 +1,177 @@
+require 'codily/update_payload'
+
+require 'codily/elements/service'
+
+require 'codily/elements/condition'
+require 'codily/elements/backend'
+require 'codily/elements/cache_setting'
+require 'codily/elements/dictionary'
+require 'codily/elements/domain'
+require 'codily/elements/gzip'
+require 'codily/elements/header'
+require 'codily/elements/healthcheck'
+require 'codily/elements/request_setting'
+require 'codily/elements/response_object'
+require 'codily/elements/vcl'
+require 'codily/elements/settings'
+
+module Codily
+  class Engine
+    def initialize(fastly, present, desired, service_filter: nil)
+      @fastly = fastly
+      @present = present
+      @desired = desired
+
+      @service_filter = service_filter
+    end
+
+    attr_reader :fastly, :present, :desired, :service_filter
+
+    ORDER = [
+      Elements::Service,
+      Elements::Settings,
+      Elements::Condition,
+      Elements::Backend,
+      Elements::CacheSetting,
+      Elements::Dictionary,
+      Elements::Domain,
+      Elements::Gzip,
+      Elements::Header,
+      Elements::Healthcheck,
+      Elements::RequestSetting,
+      Elements::ResponseObject,
+      Elements::Vcl,
+    ]
+
+    def run(dry_run: false)
+      if dry_run
+        puts "(dry-run)"
+        puts
+      end
+
+      act_any = false
+      act = false
+
+      creations.each do |new_element|
+        act_any = act = true
+        puts "CREATE: #{new_element.inspect}"
+
+        hash = new_element.as_hash
+
+        if new_element.parent_class == Elements::Service
+          service_version = present.service_version_get(new_element.service_name)
+          hash[:service_id] = service_version[:id]
+          hash[:version] = service_version[:dev]
+        end
+
+        unless dry_run
+          new_obj = fastly.create(new_element.fastly_class, hash)
+
+          if new_element.class == Elements::Service
+            present.service_version_set(new_obj.name, new_obj.id, new_obj.versions)
+          end
+        end
+      end
+
+      puts if act
+      act = false
+
+      updates.each do |present_elem, desired_elem|
+        act_any = act = true
+        puts "UPDATE: - #{present_elem.inspect}"
+        puts "        + #{desired_elem.inspect}"
+
+        payload = UpdatePayload.new(name: present_elem.name, id: present_elem.id, hash: desired_elem.as_hash)
+        if desired_elem.parent_class == Elements::Service
+          service_version = present.service_version_get(desired_elem.service_name)
+          payload.service_id = service_version[:id]
+          payload.version_number = service_version[:dev]
+        end
+
+        unless dry_run
+          fastly.update(desired_elem.fastly_class, payload)
+        end
+      end
+
+      puts if act
+      act = false
+
+      removals.each do |removed_element|
+        act_any = act = true
+        puts "DELETE: #{removed_element.inspect}"
+
+        unless dry_run
+          removed_element.fastly_obj.delete!
+        end
+      end
+
+      unless act_any
+        puts "No difference."
+      end
+      act_any
+    end
+
+    def creations
+      new_keys = desired_element_keys - present_element_keys
+      sort_elements(new_keys.map{ |_| desired.elements[_[0]][_[1]] })
+    end
+
+    def updates
+      common = present_element_keys & desired_element_keys
+
+      present_existing = common.map{ |_| present.elements[_[0]][_[1]] }
+      desired_existing = common.map{ |_| desired.elements[_[0]][_[1]] }
+
+      raise '!?' if present_existing.size != desired_existing.size
+
+      present_existing.zip(desired_existing).map do |present_elem, desired_elem|
+        if present_elem.as_hash != desired_elem.as_hash
+          [present_elem, desired_elem]
+        else
+          nil
+        end
+      end.compact.sort_by { |_| ORDER.index(_[0].class) }
+    end
+
+    def removals
+      removed_keys = present_element_keys - desired_element_keys
+      sort_elements(removed_keys.map{ |_| present.elements[_[0]][_[1]] })
+    end
+
+    private
+
+    def present_elements
+      @present_elements ||= filter_elements(present.all_elements)
+    end
+
+    def desired_elements
+      @desired_elements ||= filter_elements(desired.all_elements)
+    end
+
+    def present_element_keys
+      @present_element_keys ||= present_elements.map { |_| [_.class, _.key] }
+    end
+
+    def desired_element_keys
+      @desired_element_keys ||= desired_elements.map { |_| [_.class, _.key] }
+    end
+
+    def present_service_names
+      @present_service_names ||= present.list_element(Elements::Service).each_value.map(&:name)
+    end
+
+    def filter_elements(elems)
+      elems.select do |e|
+        if e.parent_class == Elements::Service
+          (@service_filter ? @service_filter.any? { |_| _ === e.service_name } : true) && present_service_names.include?(e.service_name)
+        else
+          true
+        end
+      end
+    end
+
+    def sort_elements(elems)
+      elems.sort_by { |_| ORDER.index(_.class) }
+    end
+  end
+end

data/lib/codily/fastly_ext.rb

@@ -0,0 +1,20 @@
+require 'fastly'
+
+class Fastly::RequestSetting
+  attr_accessor :timer_support
+end
+
+module Codily
+  module FastlyExt
+    def initialize(opts)
+      super
+      @opts = opts
+    end
+
+    def client(opts = nil)
+      (Thread.current[:fastly_client] ||= {})[self.__id__] ||= Fastly::Client.new(opts || @opts)
+    end
+  end
+end
+
+Fastly.__send__(:prepend, Codily::FastlyExt)

data/lib/codily/importer.rb

@@ -0,0 +1,77 @@
+require 'fastly'
+require 'codily/fastly_ext'
+
+require 'codily/root'
+
+require 'codily/elements/service'
+
+require 'codily/elements/backend'
+require 'codily/elements/cache_setting'
+require 'codily/elements/condition'
+require 'codily/elements/dictionary'
+require 'codily/elements/domain'
+require 'codily/elements/gzip'
+require 'codily/elements/header'
+require 'codily/elements/healthcheck'
+require 'codily/elements/request_setting'
+require 'codily/elements/response_object'
+require 'codily/elements/vcl'
+require 'codily/elements/settings'
+
+module Codily
+  class Importer
+    def initialize(fastly, import_targets: {}, service_filter: nil, debug: false)
+      @fastly = fastly
+      @import_targets = import_targets
+      @service_filter = service_filter
+
+      @ran = false
+      @root = Codily::Root.new(debug: debug)
+    end
+
+    attr_reader :fastly, :root
+
+    def run
+      return self if @ran
+
+      fastly.list_services.each do |service|
+        if @service_filter
+          next unless @service_filter.any? { |_| _ === service.name }
+        end
+        service_version = root.service_version_set(service.name, service.id, service.versions)
+        import_version = @import_targets[service.id] || @import_targets[service.name] || service_version[:dev]
+
+        root.add_element Elements::Service.new(root, service)
+
+        threads = {
+          Elements::Backend => proc { fastly.list_backends(service_id: service.id, version: import_version) },
+          Elements::CacheSetting => proc { fastly.list_cache_settings(service_id: service.id, version: import_version) },
+          Elements::Condition => proc { fastly.list_conditions(service_id: service.id, version: import_version) },
+          Elements::Dictionary => proc { fastly.list_dictionaries(service_id: service.id, version: import_version) },
+          Elements::Domain => proc { fastly.list_domains(service_id: service.id, version: import_version) },
+          Elements::Gzip => proc { fastly.list_gzips(service_id: service.id, version: import_version) },
+          Elements::Header => proc { fastly.list_headers(service_id: service.id, version: import_version) },
+          Elements::Healthcheck => proc { fastly.list_healthchecks(service_id: service.id, version: import_version) },
+          Elements::RequestSetting => proc { fastly.list_request_settings(service_id: service.id, version: import_version) },
+          Elements::ResponseObject => proc { fastly.list_response_objects(service_id: service.id, version: import_version) },
+          Elements::Vcl => proc { fastly.list_vcls(service_id: service.id, version: import_version) },
+          Elements::Settings => proc { [fastly.get_settings(service.id, import_version)] },
+        }.map do |k, list_proc|
+          Thread.new(k) do |klass|
+            list_proc.call.map do |_|
+              klass.new(root, _)
+            end
+          end
+        end
+
+        threads.each(&:value)
+        threads.flat_map(&:value).each do |elem|
+          root.add_element elem
+        end
+      end
+
+      @ran = true
+      self
+    end
+  end
+end

data/lib/codily/root.rb

@@ -0,0 +1,83 @@
+require 'fastly'
+require 'codily/elements/service'
+
+module Codily
+  class Root
+    class AlreadyDefined < StandardError; end
+
+    def initialize(debug: false)
+      @debug = debug
+      @elements = {}
+
+      @service_versions = {}
+      @service_map_name_to_id = {}
+    end
+
+    attr_reader :elements
+    attr_accessor :debug
+
+    def as_hash
+      {}
+    end
+
+    def as_dsl_hash
+      as_hash
+    end
+
+    # XXX: is it okay having this here?
+    def service_version_set(service_name, service_id, versions)
+      @service_map_name_to_id[service_name] = service_id
+      dev = versions.reverse_each.find { |_| !_.locked }.number
+      active = (versions.reverse_each.find(&:active) || versions.reverse_each.find(&:locked)).number
+      @service_versions[service_id] = {dev: dev, active: active, name: service_name, id: service_id}
+    end
+
+    def service_version_get(name_or_id)
+      @service_versions[@service_map_name_to_id[name_or_id] || name_or_id]
+    end
+
+    def services
+      list_element(Elements::Service)
+    end
+
+    def service(name, &block)
+      raise AlreadyDefined if services.key?(name)
+      add_element(Elements::Service.new(self, {name: name}, &block))
+    end
+
+
+    def run_block(&block)
+      raise ArgumentError, 'block not given' unless block
+
+      instance_eval &block
+      self
+    end
+
+    def run_string(str, file = '(eval)', line = 1)
+      instance_eval str, file, line
+      self
+    end
+
+
+    def add_element(element)
+      h = (@elements[element.class] ||= {})
+      raise AlreadyDefined, "#{element.class.name}(#{element.key}) is already defined: (#{h.keys.inspect})" if h.key?(element.key)
+      if debug
+        puts "DEBUG: #{self.class}/#{'%x' % self.__id__}(add_element): #{element.class}(#{element.key.inspect}) #{element.as_hash.inspect}"
+      end
+      h[element.key] = element
+    end
+
+    def list_element(klass)
+      @elements[klass] ||= {}
+    end
+
+    def find_element(element)
+      list_element(element.class)[element.key]
+    end
+
+    def all_elements
+      @elements.each_value.flat_map(&:values)
+    end
+  end
+end

data/lib/codily/update_payload.rb

@@ -0,0 +1,19 @@
+module Codily
+  class UpdatePayload
+    def initialize(id: nil, service_id: nil, version_number: nil, name: nil, hash: nil)
+      @id = id
+      @service_id = service_id
+      @version_number = version_number
+      @name = name
+      @hash = hash
+    end
+
+    attr_accessor :id, :service_id, :version_number, :name, :hash
+
+    alias version version_number
+
+    def as_hash
+      @hash
+    end
+  end
+end

data/lib/codily/utils.rb

@@ -0,0 +1,18 @@
+module Codily
+  module Utils
+    def self.symbolize_keys(obj)
+      case obj
+      when Hash
+        Hash[
+          obj.map do |k, v|
+            [k.to_sym, symbolize_keys(v)]
+          end
+        ]
+      when Array
+        obj.map { |_| symbolize_keys(_) }
+      else
+        obj
+      end
+    end
+  end
+end

data/lib/codily/version.rb

@@ -0,0 +1,3 @@
+module Codily
+  VERSION = "0.1.0.beta"
+end

data/lib/codily.rb

@@ -0,0 +1,6 @@
+require 'codily/version'
+require 'codily/cli'
+require 'codily/importer'
+require 'codily/dumper'
+require 'codily/engine'
+

data/script/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "codily"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/script/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

metadata

@@ -0,0 +1,138 @@
+--- !ruby/object:Gem::Specification
+name: codily
+version: !ruby/object:Gem::Version
+  version: 0.1.0.beta
+platform: ruby
+authors:
+- Sorah Fukumori
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-06-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: fastly
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: 
+email:
+- her@sorah.jp
+executables:
+- codily
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/codily
+- codily.gemspec
+- lib/codily.rb
+- lib/codily/cli.rb
+- lib/codily/dumper.rb
+- lib/codily/elements/backend.rb
+- lib/codily/elements/base.rb
+- lib/codily/elements/cache_setting.rb
+- lib/codily/elements/condition.rb
+- lib/codily/elements/dictionary.rb
+- lib/codily/elements/domain.rb
+- lib/codily/elements/file_loadable.rb
+- lib/codily/elements/gzip.rb
+- lib/codily/elements/header.rb
+- lib/codily/elements/healthcheck.rb
+- lib/codily/elements/request_setting.rb
+- lib/codily/elements/response_object.rb
+- lib/codily/elements/service.rb
+- lib/codily/elements/service_belongging_base.rb
+- lib/codily/elements/settings.rb
+- lib/codily/elements/vcl.rb
+- lib/codily/engine.rb
+- lib/codily/fastly_ext.rb
+- lib/codily/importer.rb
+- lib/codily/root.rb
+- lib/codily/update_payload.rb
+- lib/codily/utils.rb
+- lib/codily/version.rb
+- script/console
+- script/setup
+homepage: https://github.com/sorah/codily
+licenses:
+- MIT
+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: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.4
+signing_key: 
+specification_version: 4
+summary: Codificate Fastly configuration
+test_files: []