codily 0.1.0.beta

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3d995bf7783e0bfd8753d031d84a17baada6c7fc
+  data.tar.gz: 5bffd97e4de0bf768b604bd8e90673859494e58d
+SHA512:
+  metadata.gz: 23f7949471655a5381d7b3c2e89ba53072e691deaafacfd95de2d217b5d5539dd9045c9570da6b242ac2869155a96b777aa6dc0fc5aab625bf4694df5bcb0bae
+  data.tar.gz: f8d71e4a5b1a006b49d49c64bdd46852c77e4dbfa29e31cb99aa225a7ce5ba2408d66c954c1af3e06518458ed291b09d70c89224f5d561b0cc8297df0a068caa

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.4.0
+before_install: gem install bundler -v 1.12.5

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Sorah Fukumori
+
+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,263 @@
+# Codily: Codificate your Fastly configuration
+
+__still in beta__
+
+Codily allows you to manage your Fastly configuration in Ruby DSL!
+
+## Installation
+
+```ruby
+# Gemfile
+gem 'codily'
+```
+
+Or install it yourself as:
+
+    $ gem install codily --pre
+
+## Usage
+
+
+```
+Usage: codily [options]
+    -a, --apply
+    -e, --export
+    -v, --version
+    -f, --file PATH                  file to apply, or file path to save exported file (default to ./codily.rb on applying)
+    -t, --target REGEXP              Filter services by name to apply or export.
+    -n, --dry-run                    Just displays the oprerations that would be performed, without actually running them.
+    -D, --debug                      Debug mode
+    -V, --target-version SVC_VER     Choose version to export (format= service_name:version) This option can be used multiple time.
+```
+
+```
+codily --help
+
+codily --export
+codily --export --target my-service
+codily --export --target my-service --target-version my-service:42
+codily --export --file ./codily.rb
+
+codily --apply --file ./codily.rb
+codily --apply --file ./codily.rb --dry-run
+codily --apply --file ./codily.rb --target my-service
+```
+
+## Restrictions
+
+- Directors are not supported due to its deprecation
+
+## DSL
+
+### tl;dr
+
+It's easy to start by export existing configuration into DSL using `--export` option.
+
+``` ruby
+service "foo" do
+  backend "my backend" do
+    address "example.com"
+  end
+end
+```
+
+### Loading file
+
+some attributes (e.g. tls certificates, tls keys, VCL content, response object content) supports loading value from a file.
+
+``` ruby
+service "foo" do
+  vcl "default" do
+    main true
+    content file: './my.vcl'
+  end
+end
+```
+
+### Referring other object (e.g. condition)
+
+Some attributes that refers other object (e.g. conditions), you can define referring object as like the following:
+
+``` ruby
+service "foo" do
+  response_object "method not allowed" do
+    status "405"
+    response "Method Not Allowed"
+    content "405"
+    content_type "text/plain"
+
+    request_condition "request method is not GET, HEAD or FASTLYPURGE" do
+      priority 10
+      statement '!(req.request == "GET" || req.request == "HEAD" || req.request == "FASTLYPURGE")'
+    end
+  end
+end
+
+# equals as follows:
+
+service "foo" do
+  condition "request method is not GET, HEAD or FASTLYPURGE" do
+    priority 10
+    statement '!(req.request == "GET" || req.request == "HEAD" || req.request == "FASTLYPURGE")'
+    type "REQUEST"
+  end
+
+  response_object "method not allowed" do
+    status "405"
+    response "Method Not Allowed"
+    content "405"
+    content_type "text/plain"
+    request_condition "request method is not GET, HEAD or FASTLYPURGE"
+  end
+end
+```
+
+### Full example
+
+Basically, all attributes are 
+
+``` ruby
+service "test.example.com" do
+  backend "name" do
+    address
+    auto_loadbalance
+    between_bytes_timeout
+    client_cert
+    comment
+    connect_timeout
+    error_threshold
+    first_byte_timeout
+    healthcheck
+    hostname
+    max_conn
+    max_tls_version
+    min_tls_version
+    port
+    request_condition
+    service_id
+    shield
+    ssl_ca_cert
+    ssl_cert_hostname
+    ssl_check_cert
+    ssl_ciphers
+    ssl_client_cert
+    ssl_client_key
+    ssl_hostname
+    ssl_sni_hostname
+    use_ssl
+    weight
+  end
+
+  cache_setting "name" do
+    action
+    stale_ttl
+    ttl
+
+    cache_condition "name"
+    # cache_condition do
+    #   comment
+    #   priority
+    #   statement
+    # end
+  end
+
+  condition "name" do
+    comment
+    priority
+    statement
+  end
+
+  dictionary "name"
+
+  domain "a.example.org"
+  domain "a.example.org" do
+    comment ""
+  end
+
+  gzip "name" do
+    content_types %w(text/html)
+    extensions %w(html)
+    cache_condition "name"
+    # cache_condition do
+    #   comment
+    #   priority
+    #   statement
+    # end
+  end
+
+  header 'name' do
+    action
+    src
+    dst
+    ignore_if_set
+    priority
+    substitution
+    type
+    cache_condition
+    request_condition
+    response_condition
+  end
+
+  healthcheck 'name' do
+    check_interval
+    comment
+    expected_response
+    host
+    http_version
+    initial
+    method
+    path
+    threshold
+    timeout
+    window
+  end
+
+  request_setting "name" do
+    action
+    bypass_busy_wait
+    default_host
+    force_miss
+    force_ssl
+    geo_headers
+    hash_keys
+    max_stale_age
+    timer_support
+    xff
+    request_condition
+  end
+
+  response_object "name" do
+    content
+    content_type
+    status
+    response
+    cache_condtiion
+    request_condition
+  end
+
+  vcl "name" do
+    content file: 'xxx'
+    main true
+  end
+
+  settings(
+    "general.default_ttl": 3600,
+  )
+end
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/sorah/codily.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/codily

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+require 'codily'
+
+$stdout.sync = true
+
+exit Codily::Cli.new(ARGV).run || 128

data/codily.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'codily/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "codily"
+  spec.version       = Codily::VERSION
+  spec.authors       = ["Sorah Fukumori"]
+  spec.email         = ["her@sorah.jp"]
+
+  spec.summary       = %q{Codificate Fastly configuration}
+  spec.homepage      = "https://github.com/sorah/codily"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "bin"
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "fastly"
+
+  spec.add_development_dependency "bundler", ">= 1.12"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

data/lib/codily/cli.rb

@@ -0,0 +1,142 @@
+require 'optparse'
+
+require 'codily/root'
+require 'codily/importer'
+require 'codily/dumper'
+require 'codily/engine'
+
+require 'fastly'
+
+module Codily
+  class Cli
+    def initialize(argv)
+      @argv = argv.dup
+    end
+
+    def run
+      optparse.parse!(@argv)
+      case options[:mode]
+      when :version
+        do_version
+      when :apply
+        do_apply
+      when :export
+        do_export
+      else
+        $stderr.puts "ERROR: you should choose operation from --apply (-a), or --export (-e)"
+        $stderr.puts
+        $stderr.puts optparse.help
+        16
+      end
+    end
+
+    def do_version
+      puts "Codily #{Codily::VERSION}"
+      0
+    end
+
+    def do_apply
+      options[:file] ||= './codily.rb'
+      Dir.chdir(File.dirname(options[:file]))
+
+      present = importer.run.root
+      desired = Root.new(debug: options[:debug]).run_string(File.read(File.basename(options[:file])), options[:file], 1)
+
+      require_fastly_auth!
+
+      engine = Engine.new(fastly, present, desired, service_filter: options[:target])
+
+      act = engine.run(dry_run: options[:dry_run])
+
+      0
+    end
+
+    def do_export
+      if options[:file] && File.exist?(options[:file])
+        raise "File #{options[:file].inspect} already exists!"
+      end
+
+      require_fastly_auth!
+
+      importer.run
+
+      rb = Dumper.new(importer.root).ruby_code
+
+      if options[:file]
+        File.write options[:file], rb
+      else
+        puts rb
+      end
+
+      0
+    end
+
+    def importer
+      @importer ||= Importer.new(fastly, service_filter: @options[:target], import_targets: @options[:export_versions], debug: @options[:debug])
+    end
+
+    def options
+      @options ||= {
+        file: nil,
+        export_versions: {},
+        debug: false,
+        dry_run: false,
+        apply: false,
+        activate: false,
+      }
+    end
+
+    def optparse
+      @optparse ||= OptionParser.new do |opt|
+        opt.on('-a', '--apply') { options[:mode] = :apply }
+        opt.on('-e', '--export') { options[:mode] = :export }
+        opt.on('-v', '--version') { options[:mode] = :version }
+
+        opt.on('-f PATH', '--file PATH', 'file to apply, or file path to save exported file (default to ./codily.rb on applying)') do |file|
+          options[:file] = file
+        end
+
+        opt.on('-t REGEXP', '--target REGEXP', 'Filter services by name to apply or export.') do |regexp|
+          options[:target] = [Regexp.new(regexp)]
+        end
+
+        opt.on('-n', '--dry-run', "Just displays the oprerations that would be performed, without actually running them.") do
+          options[:dry_run] = true
+        end
+
+        opt.on('-D', '--debug', "Debug mode") do
+          options[:debug] = true
+        end
+
+        #opt.on('-A', '--activate', "Activate after apply") do
+        #  options[:activate] = true
+        #end
+
+        #opt.on('-d', '--diff', "Call diff API after apply") do
+        #  options[:diff] = true
+        #end
+
+        opt.on('-V SVC_VER', '--target-version SVC_VER', "Choose version to export (format= service_name:version) This option can be used multiple time.") do |svcvers|
+          svcver = svcvers.split(?:)
+          ver = svcver.pop
+          svc = svcver.join(?:)
+          options[:export_versions][svc] = ver.to_i
+        end
+      end
+    end
+
+    def fastly
+      @fastly ||= begin
+        Fastly.new(api_key: ENV['FASTLY_API_KEY'])
+      end
+    end
+
+    private
+
+    def require_fastly_auth!
+      unless fastly.authed?
+        raise "Cannot authenticate with Fastly. Make sure to have environment variable FASTLY_API_KEY!"
+      end
+    end
+  end
+end

data/lib/codily/dumper.rb

@@ -0,0 +1,89 @@
+require 'codily/elements/condition'
+
+module Codily
+  class Dumper
+    def initialize(root)
+      @root = root
+    end
+
+    attr_reader :root
+
+    def tree
+      # :children:
+      #   service: (element_tree)
+      #     KEY:
+      #       :self: Elements::Base
+      #       :children:
+      #         healthcheck:
+      #           KEY:
+      #             :self: Elements::Base
+      @tree ||= {self: root, children: {}}.tap do |tree|
+        root.elements.each_key.sort_by { |klass| [klass.path.size, klass == Elements::Condition ? 0 : 1] }.each do |klass|
+          elements = root.list_element(klass)
+
+          elements.each do |key, element|
+            parents = element.parents
+            subtree = parents.inject(tree) { |r,i| r[:children][i.class.name_for_attr][i.key] }
+            (subtree[:children][element.class.name_for_attr] ||= {})[element.key] = {self: element, children: {}}
+          end
+        end
+      end
+    end
+
+    def simple_tree
+      simplize_tree tree
+    end
+
+    def ruby_code
+      "#{dump_ruby_code(tree)}\n"
+    end
+    
+    private
+
+    def simplize_tree(leaf)
+      {}.tap do |tree|
+        tree.merge! leaf[:self].as_dsl_hash
+        leaf[:children].each do |name, children|
+          tree[name] = {}
+          children.each do |key, child|
+            tree[name][child[:self].dsl_args] = simplize_tree(child)
+          end
+        end
+      end
+    end
+
+    def dump_ruby_code(tree, level=0)
+      indent = '  ' * level
+      lines = []
+
+      attrs =tree[:self].as_dsl_hash
+      attrs.each do |key, value|
+        value_str = value.inspect
+        if value.kind_of?(Hash)
+          value_str = value_str.gsub(/\A{|}\z/, '')
+        end
+        lines << "#{indent}#{key} #{value_str}"
+      end
+
+      lines << nil if !attrs.empty? && !tree[:children].empty?
+
+      tree[:children].each_with_index do |(name, children), i|
+        lines << nil if i > 0
+        children.each_with_index do |(key, child), j|
+          lines << nil if j > 0
+
+          value_str = child[:self].dsl_args.map(&:inspect).join(?,)
+          if child[:self].dsl_args.size == 1 && child[:self].dsl_args[0].kind_of?(Hash)
+            value_str = value_str.gsub(/\A{|}\z/, '')
+          end
+
+          lines << "#{indent}#{name} #{value_str} do"
+          lines << dump_ruby_code(child, level.succ)
+          lines << "#{indent}end"
+        end
+      end
+
+      lines.join("\n").gsub(/ do\n\n\s+end/,'')
+    end
+  end
+end

data/lib/codily/elements/backend.rb

@@ -0,0 +1,78 @@
+require 'codily/elements/service_belongging_base'
+require 'codily/elements/healthcheck'
+
+require 'codily/elements/file_loadable'
+
+module Codily
+  module Elements
+    class Backend < ServiceBelonggingBase
+      include FileLoadable
+
+      defaults(
+        port: 80,
+        weight: 100,
+        auto_loadbalance: true,
+        between_bytes_timeout: 10000,
+        connect_timeout: 1000,
+        error_threshold: 0,
+        first_byte_timeout: 15000,
+        ssl_check_cert: true,
+      )
+
+      def setup
+        delete_if_empty!(*%i(
+          hostname
+          address
+          request_condition
+          healthcheck
+          comment
+          shield
+        ))
+      end
+
+      def_attr *%i(
+        address
+        auto_loadbalance
+        between_bytes_timeout
+        comment
+        connect_timeout
+        error_threshold
+        first_byte_timeout
+        hostname
+        ipv4
+        ipv6
+        max_conn
+        max_tls_version
+        min_tls_version
+        port
+        shield
+        ssl_cert_hostname
+        ssl_ciphers
+        ssl_hostname
+        ssl_sni_hostname
+        ssl_check_cert
+        use_ssl
+        weight
+      )
+
+      def_file_loadable_attr *%i(
+        client_cert
+        ssl_ca_cert
+        ssl_client_cert
+        ssl_client_key
+      )
+
+      def healthcheck(name = nil, &block)
+        set_refer_element(:healthcheck, Healthcheck, {name: name, _service_name: self.service_name}, &block)
+      end
+
+      def request_condition(name = nil, &block)
+        set_refer_element(:request_condition, Condition, {name: name, _service_name: self.service_name}, &block)
+      end
+
+      def fastly_class
+        Fastly::Backend
+      end
+    end
+  end
+end