matsuri 0.1.0 → 0.3.0

data/lib/matsuri/cmds/status.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Matsuri
+  module Cmds
+    class Status < Thor
+      include Matsuri::Cmd
+
+      def self.status_cmd_for(resource_name)
+        define_method(resource_name) do |name = :not_specified|
+          status_resource { Matsuri::Registry.fetch_or_load(resource_name, name).new }
+        end
+      end
+
+      desc 'stack STACK_NAME', 'stack status'
+      def stack(name = :not_specified)
+        with_config do |opt|
+          Matsuri::Registry.fetch_or_load(:stack, name).new.status!
+        end
+      end
+
+      desc 'pod POD_NAME', 'pod status'
+      status_cmd_for :pod
+
+      desc 'pods', 'kubectl top pods'
+      def pods
+        with_config do |_|
+          Matsuri::ShellOut.kubectl 'top pods'
+        end
+      end
+
+      desc 'nodes', 'kubectl top nodes'
+      def nodes
+        with_config do |_|
+          Matsuri::ShellOut.kubectl 'top nodes'
+        end
+      end
+
+      desc 'service SERVICE_NAME', 'service status'
+      status_cmd_for :service
+
+      desc 'endpoints ENDPOINTS_NAME', 'endpoint set status'
+      status_cmd_for :endpoints
+
+      desc 'secret SECRET_NAME', 'secret status'
+      status_cmd_for :secret
+
+      desc 'pv PV_NAME', 'persistent volume status'
+      status_cmd_for :pv
+
+      desc 'pvc PVC_NAME', 'persistent volume claim status'
+      status_cmd_for :pvc
+
+      desc 'storage_class STORAGE_CLASS_NAME', 'storage class status'
+      status_cmd_for :storage_class
+
+      private
+
+      def status_resource
+        with_config do |opt|
+          resource = yield
+          Matsuri::Tasks::KubectlOps.status(resource)
+        end
+      end
+
+    end
+  end
+end

data/lib/matsuri/concerns/awaiting.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Matsuri
+  module Concerns
+    module Awaiting
+      def awaiting!(msg, timeout: 500, interval: 10)
+        Matsuri.log :info, "Waiting for #{msg}: "
+        response = nil
+        # Ignore timeout for now
+        # Timeout::timeout(timeout) do
+          loop do
+            response = yield
+            break if response
+            sleep interval
+            print '.'
+          end
+        #end
+
+        Matsuri.log :info, ' Done.'
+        return response
+      end
+    end
+  end
+end

data/lib/matsuri/concerns/diffable.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require 'hashdiff'
+require 'unit'
+
+module Matsuri
+  module Concerns
+    # Client-side diff: compares the declared manifest against a current
+    # manifest handed in by the caller, with comparison noise filtered out.
+    # Pure computation — fetching the current manifest, presenting the
+    # declaration, and printing deltas belong to Tasks::HashDiff. The
+    # filter helpers are the per-resource override surface: a definition
+    # that knows about additional noise paths overrides them here.
+    #
+    # This diff answers "what drifted relative to my declaration". The
+    # server-side diff (kubectl diff) answers "what will the cluster do
+    # with this, admission injections included". Both are kept.
+    module Diffable
+      # current is a plain string-keyed hash, as parsed from kubectl
+      # output. desired overrides the comparison basis — Tasks::HashDiff
+      # hands in the presented declaration so drift reads against what
+      # apply would send; default is the raw declaration.
+      def diff(current, desired: nil)
+        desired ||= JSON.parse(to_json)
+
+        Hashdiff.diff(current, desired) do |path, current_value, desired_value|
+          filter_comparison_values(path, current_value, desired_value)
+        end
+      end
+
+      # Focused variant: compares only the primary container, projected out
+      # of both manifests by primary_container_path. Unfiltered — the noise
+      # filters address whole-manifest paths, which do not occur inside a
+      # container.
+      def primary_container_diff(current, desired: nil)
+        unless primary_container_path
+          Matsuri.log :fatal, "#{resource_type}/#{name} does not declare let(:primary_container_path)"
+        end
+
+        desired ||= JSON.parse(to_json)
+
+        Hashdiff.diff current.dig(*primary_container_path), desired.dig(*primary_container_path)
+      end
+
+      def filter_comparison_values(path, current_value, desired_value)
+        if empty_assignment_to_empty?(current_value, desired_value) or
+           readonly_path?(path) or
+           always_changed_path?(path) or
+           default_value_assigned_nothing?(path, current_value, desired_value) or
+           unit_comparison_is_equal?(current_value, desired_value)
+           # (
+           #   path.start_with?("metadata.") and
+           #   path !~ /^metadata\.\b(name|labels|namespace)\b/
+           # ) or
+          true
+        else
+          :perform_normal_comparison end
+      end
+
+      def empty_assignment_to_empty?(current_value, desired_value)
+        empty_value?(current_value) and empty_value?(desired_value)
+      end
+
+      def readonly_path?(path)
+        [
+          'status',
+        ].member?(path)
+      end
+
+      def always_changed_path?(path)
+        [
+           'metadata.annotations.kubectl.kubernetes.io/last-applied-configuration',
+           'metadata.annotations.kubernetes.io/change-cause',
+        ].member?(path)
+      end
+
+      def default_value_assigned_nothing?(path, current_value, desired_value)
+        # standard case of empty value desired but current value is
+        # atomic/predefined
+        (
+          empty_value?(desired_value) and
+            not (current_value.is_a?(Hash) or current_value.is_a?(Array))
+        ) or
+
+        # volumeMounts are not readOnly by default, making a setting of false
+        # redundant
+        (
+          path =~ /volumeMount.*readOnly/ and
+          current_value.nil? and
+          desired_value == false
+        ) or
+
+        # minReadySeconds is 0 by default but not presented as such
+        (
+          path == 'spec.minReadySeconds' and
+          current_value.nil? and
+          desired_value == 0
+        )
+      end
+
+      def unit_comparison_is_equal?(current_value, desired_value)
+        # Unit cannot handle nil values, so if one one of the values
+        # are empty, then return false (beacuse it is not comparable)
+        return false if empty_value?(current_value) || empty_value?(desired_value)
+        # Only strings carry quantities; Object#=~ is gone as of Ruby 3.2,
+        # so anything else must bail before the match
+        return false unless current_value.is_a?(String) and desired_value.is_a?(String)
+
+        if current_value =~ /^\d+\s*[A-Za-z]+$/ or desired_value =~ /^\d+\s*[A-Za-z]+$/
+          (
+            includes_unit?(current_value) and
+            includes_unit?(desired_value) and
+            Unit(current_value) == Unit(desired_value)
+          ) or
+          (
+            Unit(current_value + 'B') == Unit(desired_value + 'B')
+          )
+        else
+          false
+        end
+      end
+
+      def includes_unit?(value)
+        Unit(value)
+        true
+      rescue TypeError
+        false
+      end
+
+      def empty_value?(value)
+        value.nil? or value == {} or value == [] or value == ""
+      end
+    end
+  end
+end

data/lib/matsuri/concerns/export_manifest.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'rlet/concern'
+
+module Matsuri
+  module Concerns
+    module ExportManifest
+      extend Concern
+
+      included do
+
+        let(:core_manifest) do
+          {
+            apiVersion:  api_version,
+            kind:        kind,
+            metadata:    metadata
+          }
+        end
+
+        let(:manifest)         { fail Matsuri::UndefinedLet, 'Must define let(:manifest)' }
+
+        # Some resources only allow certain fields to be applied. Override this
+        # to restrict it.
+        let(:applied_manifest)            { manifest }
+        let(:manifest_for_export)         { manifest.deep_stringify_keys }
+        let(:applied_manifest_for_export) { applied_manifest.deep_stringify_keys }
+
+        let(:api_version) { fail Matsuri::UndefinedLet, 'Must define let(:api_version)' }
+        let(:kind)        { fail Matsuri::UndefinedLet, 'Must define let(:kind)' }
+        let(:metadata)    { { } }
+        let(:name)        { fail Matsuri::UndefinedLet, 'Must define let(:name)' }
+        let(:spec)        { fail Matsuri::UndefinedLet, 'Must define let(:spec)' }
+      end
+
+      def to_json
+        manifest_for_export.to_json
+      end
+
+      def to_yaml
+        manifest_for_export.to_yaml
+      end
+
+      def applied_to_json
+        applied_manifest_for_export.to_json
+      end
+
+      def applied_to_yaml
+        applied_manifest_for_export.to_yaml
+      end
+
+      def pretty_print
+        JSON.pretty_generate(manifest)
+      end
+    end
+  end
+end

data/lib/matsuri/concerns/import_manifest.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Matsuri
+  module Concerns
+    # The import surface: locating a vendor manifest file, extracting
+    # documents from it, and the set-carrier lookups that address manifests
+    # within a stream by {kind, name, namespace}. The transform vocabulary
+    # (set_env, append_volume, update_in, and friends) comes from
+    # Matsuri::Transform::Kubernetes, included here, so local customization
+    # of imported manifests uses the same dialect as presenters.
+    module ImportManifest
+      extend Concern
+
+      included do
+        include Matsuri::Transform::Kubernetes
+
+        let(:import_path)           { fail Matsuri::UndefinedLet, 'Must define let(:import_path)' }
+
+        ### Override
+        let(:imported_metadata)     { imported_pod_metadata }
+        let(:imported_labels)       { final_metadata.get(:labels) }
+
+        let(:imported_pod_metadata) { imported_manifest.get(:spec, :template, :metadata) }
+        let(:imported_pod_spec)     { imported_manifest.get(:spec, :template, :spec) }
+        let(:imported_manifest)     { Map.new(YAML.load_file(full_import_path)) }
+        let(:full_import_path)      { File.join(Matsuri::Config.imported_manifests_path, import_path)}
+
+        # Support for finding and extracting a manifest from a stream (multiple yaml documents in a file)
+        # Override with:
+        # let(:imported_manifest) { extracted_manifest }
+        # let(:import_filter_criteria) { { kind: "Something", name: "something", namespace: "something" }}
+
+        let(:extracted_manifest)     { Map.new(lookup_manifests(imported_manifests, import_filter_criteria).first) }
+        let(:imported_manifests)     { YAML.load_stream(File.read(full_import_path)) }
+        let(:import_filter_criteria) { fail Matsuri::UndefinedLet, 'Must define let(:import_filter_criteria)' }
+      end
+
+      # Assumes that the complex key of {kind, name, namespace} is unique within a given set of manifests
+      def lookup_manifests(set, criteria)
+        raise ArgumentError, "Must pass name: and kind: for criteria" unless criteria[:kind] && criteria[:name]
+        set.select(&criteria_matcher(criteria))
+      end
+
+      # This is used when we have a collection of manifests, more useful for importing a bundle
+      # using Matsuri::Kubernetes::ImportedManifest (importing raw manifests from a vendor upstream)
+      def without_manifest(set, criteria)
+        raise ArgumentError, "Must pass name: and kind: for criteria" unless criteria[:kind] && criteria[:name]
+
+        set.reject(&criteria_matcher(criteria))
+      end
+
+      def criteria_matcher(criteria)
+        ->(hash) { matches_criteria?(hash, criteria) }
+      end
+
+      def matches_criteria?(hash, criteria)
+        h = Map.new(hash)
+        h.get(:kind) == criteria[:kind] &&
+          h.get(:metadata, :name) == criteria[:name] &&
+          (criteria[:namespace] == nil || h.get(:metadata, :namespace) == criteria[:namespace])
+      end
+    end
+  end
+end

data/lib/matsuri/concerns/pod_template.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'yaml'
+require 'rlet/concern'
+
+module Matsuri
+  module Concerns
+    # Mixin for K8S resources that uses pod template
+    module PodTemplate
+      extend Concern
+
+      included do
+        # Define this to point to an existing pod definition. This is the name
+        # registered to Matsuri::Registry
+        let(:pod_name) { fail Matsuri::UndefinedLet, 'Must define let(:pod_name)' }
+
+        # By default, point the template to an existing pod definition
+        # Overide let(:pod_name)
+        let(:template) { { metadata: { labels: pod_labels, annotations: pod_annotations }, spec: pod_spec } }
+
+        let(:pod_def)             { pod(pod_name, pod_options) }
+        let(:primary_image)       { pod_def.primary_image }
+        let(:primary_container)   { pod_def.primary_container }
+        let(:pod_labels)          { pod_def.final_labels }
+        let(:pod_annotations)     { pod_def.final_annotations }
+        let(:pod_spec)            { pod_def.spec }
+        let(:pod_options)         { default_pod_options }
+        # Once mapped, the acceptor instance is the accepted values; the
+        # template forwards it so pod definitions read the same binding the
+        # owning resource holds.
+        let(:default_pod_options) { { image_tag: image_tag, stack_config: stack_config } }
+      end
+
+    end
+  end
+end

data/lib/matsuri/concerns/pods/spread_pods.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'rlet/concern'
+
+module Matsuri
+  module Concerns
+    module Pods
+      # Pod anti-affinity vocabulary for spreading pods that share the same
+      # labels across nodes or zones. Not included in Pod by default; include
+      # it in a definition and select a strategy:
+      #
+      #   include Matsuri::Concerns::Pods::SpreadPods
+      #   let(:pod_anti_affinity) { schedule_one_per_zone }
+      #
+      module SpreadPods
+        extend Concern
+
+        included do
+          let(:pod_anti_affinity)          { fail Matsuri::UndefinedLet, 'define let(:pod_anti_affinity) required' }
+
+          let(:schedule_one_per_node)      { required_during_scheduling(other_pods_of_type_in_node) }
+          let(:schedule_one_per_zone)      { required_during_scheduling(other_pods_of_type_in_zone) }
+
+          # preferredDuringScheduling entries must be weighted terms
+          let(:prefer_one_per_node)        { preferred_during_scheduling(weighted_other_pods_of_type_in_node) }
+          let(:prefer_one_per_zone)        { preferred_during_scheduling(weighted_other_pods_of_type_in_zone) }
+
+          let(:other_pods_of_type_in_node) { pod_affinity_term match_labels: anti_affinity_labels }
+          let(:other_pods_of_type_in_zone) { pod_affinity_term match_labels: anti_affinity_labels, topology_key: zone_topology_key }
+
+          let(:weighted_other_pods_of_type_in_node) { weighted_pod_affinity_term match_labels: anti_affinity_labels, weight: spread_weight }
+          let(:weighted_other_pods_of_type_in_zone) { weighted_pod_affinity_term match_labels: anti_affinity_labels, weight: spread_weight, topology_key: zone_topology_key }
+
+          let(:spread_weight)              { 100 }
+
+          # Well-known topology label, set by the cloud provider on GKE and
+          # EKS alike. Its deprecated predecessor,
+          # failure-domain.beta.kubernetes.io/zone, is no longer applied to
+          # nodes.
+          let(:zone_topology_key)          { 'topology.kubernetes.io/zone' }
+
+          let(:anti_affinity_labels)       { labels }
+        end
+      end
+    end
+  end
+end

data/lib/matsuri/concerns/pods/spread_topology.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'rlet/concern'
+
+module Matsuri
+  module Concerns
+    module Pods
+      # Topology spread constraint vocabulary for balancing same-labeled pods
+      # across topology domains. Not included in Pod by default; include it in
+      # a definition and select a strategy:
+      #
+      #   include Matsuri::Concerns::Pods::SpreadTopology
+      #   let(:topology_spread_constraints) { balance_across_zones }
+      #
+      # Strategies return lists, so they compose by concatenation:
+      #
+      #   let(:topology_spread_constraints) { balance_across_zones + balance_across_nodes }
+      #
+      # Complements Concerns::Pods::SpreadPods: spread constraints express
+      # balance (bounded skew of replica counts per domain), anti-affinity
+      # expresses exclusion (no co-location within a domain). Definitions
+      # commonly carry both — zone balance here, node exclusion there.
+      # zone_topology_key is the same noun in both concerns, so one override
+      # re-points both mechanisms.
+      module SpreadTopology
+        extend Concern
+
+        included do
+          let(:topology_spread_constraints) { fail Matsuri::UndefinedLet, 'define let(:topology_spread_constraints) required' }
+
+          ### Strategies: one builder, specialized by topology key
+          let(:balance_across_zones) { [balanced_spread(zone_topology_key, max_skew: zone_max_skew, when_unsatisfiable: zone_when_unsatisfiable)] }
+          let(:balance_across_nodes) { [balanced_spread(node_topology_key, max_skew: node_max_skew, when_unsatisfiable: node_when_unsatisfiable)] }
+
+          ### Topology keys
+          let(:zone_topology_key)    { 'topology.kubernetes.io/zone' }
+          let(:node_topology_key)    { 'kubernetes.io/hostname' }
+
+          ### Knob ladder: shared default, per-domain override
+          let(:spread_max_skew)           { 1 }
+          let(:spread_when_unsatisfiable) { 'ScheduleAnyway' }
+
+          let(:zone_max_skew)             { spread_max_skew }
+          let(:zone_when_unsatisfiable)   { spread_when_unsatisfiable }
+          let(:node_max_skew)             { spread_max_skew }
+          let(:node_when_unsatisfiable)   { spread_when_unsatisfiable }
+
+          let(:spread_label_selector)     { label_selector(match_labels: spread_labels) }
+          let(:spread_labels)             { labels }
+        end
+
+        def balanced_spread(topology_key, max_skew: spread_max_skew, when_unsatisfiable: spread_when_unsatisfiable)
+          topology_spread_constraint(
+            topology_key:       topology_key,
+            max_skew:           max_skew,
+            when_unsatisfiable: when_unsatisfiable,
+            label_selector:     spread_label_selector
+          )
+        end
+      end
+    end
+  end
+end

data/lib/matsuri/concerns/registry_helpers.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'rlet/concern'
+
+module Matsuri
+  module Concerns
+    # This module contains helpers to make it easy to reference things
+    # around the Matsuri platforms. For example, you can reference other pods,
+    # rcs, or reference configuration settings.
+    module RegistryHelpers
+      extend Concern
+
+      included do
+        def config
+          Matsuri::Config
+        end
+
+        def platform
+          Matsuri::Platform
+        end
+
+        def please_define(key, notes = '')
+          Matsuri.log :fatal, "Please define '#{key}' in '.platform.rb'\n#{notes}"
+        end
+
+        def pod(name, opt={})
+          Matsuri::Registry.pod(name).new(opt)
+        end
+
+        def replica_set(name, opt={})
+          Matsuri::Registry.replica_set(name).new(opt)
+        end
+
+        def deployment(name, opt={})
+          Matsuri::Registry.deployment(name).new(opt)
+        end
+
+        def stateful_set(name, opt={})
+          Matsuri::Registry.stateful_set(name).new(opt)
+        end
+
+        def service(name, opt={})
+          Matsuri::Registry.service(name).new(opt)
+        end
+
+        def endpoints(name, opt={})
+          Matsuri::Registry.endpoints(name).new(opt)
+        end
+
+        def horizontal_pod_autoscaler(name, opt={})
+          Matsuri::Registry.horizontal_pod_autoscaler(name).new(opt)
+        end
+
+        alias_method :hpa, :horizontal_pod_autoscaler
+
+      end
+    end
+  end
+end

data/lib/matsuri/config.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'mixlib/config'
+require 'pathname'
+require 'matsuri/core_ext'
+
+module Matsuri
+  # Matsuri-specific configuration. These are things you probably
+  # do not want to change. User-defined configs are found in Matsuri::Platform
+  # TODO: Move K8S configs out to Platform
+  module Config
+    extend Mixlib::Config
+    config_strict_mode true  # will see how annoying this is
+
+    # Base path of the platform repo, defaults to PWD
+    default(:base_path)   { fail 'Matsuri.base_path must be set. This is usually set by the initializer' }
+    default :verbose,     false
+    default :debug,       false
+    default(:environment) { fail 'Matsuri.environment must be set. This is usually set by the initializer' }
+
+    # If set to true, then Matsuri env names will be
+    # mapped to kube_context via Matsuri::Platform.
+    # By default, Matsuri assumes that the name of the environment
+    # is the name of the kubectl context. However, if you are using
+    # this with GKE, it is easier to let gcloud handle setting up
+    # authentication, in which case we want to map environment names
+    # to kubectl context
+    # Example: staging -> Matsuri::Platform.staging.kube_context
+    # With "staging", you must define Matsuri::Platform.staging.kube_context
+    # to pull the correct kube context.
+    default :map_env_to_kube_context, false
+
+    # Networking
+    default :dev_addr, '127.0.0.1' # Replace with local ip
+
+    # Shellout defaults
+    default(:shellout_cwd)      { base_path }
+    default(:shellout_defaults) { { cwd: shellout_cwd } }
+
+    # Platform paths
+    default(:config_path)          { File.join base_path, 'config' }
+    default(:repo_defaults_path)   { File.join config_path, 'matsuri.rb' }
+    default(:initializer_path)     { File.join config_path, 'initializer.rb' }
+    default(:config_secrets_path)  { File.join config_path, 'secrets' } # Actual secrets themselves, should not be versioned
+    default(:config_overlays_path) { File.join 'etc', 'config-maps' } # Actual config files themselves
+    default(:platform_load_paths)  { [ File.join(config_path, 'platform.rb'), File.join(base_path, '.platform.rb') ] }
+
+    default(:cache_path)           { File.join base_path, '.cache' }
+    default(:build_path)           { File.join base_path, 'build' }
+    default(:docker_path)          { File.join base_path, 'docker' }
+    default(:src_path)             { File.join base_path, 'src' }
+    default(:lib_path)             { File.join base_path, 'lib' }
+    default(:platform_path)        { File.join base_path, 'platform' }
+
+    default(:images_path)                     { File.join platform_path, 'images' }
+    default(:pods_path)                       { File.join platform_path, 'pods' }
+    default(:replica_sets_path)               { File.join platform_path, 'replica_sets' }
+    default(:daemon_sets_path)                { File.join platform_path, 'daemon_sets' }
+    default(:deployments_path)                { File.join platform_path, 'deployments' }
+    default(:cron_jobs_path)                  { File.join platform_path, 'cron_jobs' }
+    default(:stateful_sets_path)              { File.join platform_path, 'stateful_sets' }
+    default(:persistent_volumes_path)         { File.join platform_path, 'persistent_volumes' }
+    default(:persistent_volume_claims_path)   { File.join platform_path, 'persistent_volume_claims' }
+    default(:storage_classes_path)            { File.join platform_path, 'storage_classes' }
+    default(:services_path)                   { File.join platform_path, 'services' }
+    default(:ingresses_path)                  { File.join platform_path, 'ingresses' }
+    default(:endpoints_path)                  { File.join platform_path, 'endpoints' }
+    default(:stacks_path)                     { File.join platform_path, 'stacks' }
+    default(:acceptors_path)                  { File.join platform_path, 'acceptors' }
+    default(:presenters_path)                 { File.join platform_path, 'presenters' }
+    default(:secrets_path)                    { File.join platform_path, 'secrets' } # Kubernetes Secret definition, not the actual secrets
+    default(:config_maps_path)                { File.join platform_path, 'config_maps' } # Kubernetes ConfigMaps definition, not the actual config ovelay
+    default(:horizontal_pod_autoscalers_path) { File.join platform_path, 'horizontal_pod_autoscalers' }
+
+    default(:clusters_path)                   { File.join platform_path, 'clusters' } # For Cluster DSL, managing cluster-wide configuration
+
+    default(:imported_manifests_path) { File.join platform_path, 'manifests' }
+    default(:manifests_path)          { File.join platform_path, 'manifests' }
+
+    # API Versions
+    default :rbac_api_version, 'rbac.authorization.k8s.io/v1'
+
+    # DSL
+    default :cluster_dsl_version, 'cluster.v1'
+
+    # Helpers
+    def self.host_osx?
+      /darwin/ =~ RUBY_PLATFORM
+    end
+
+    def self.load_configuration(config_file)
+      Matsuri::Config.from_file(config_file) if File.file?(config_file)
+    end
+
+    def self.apply_configuration(options = {})
+      Matsuri::Config.verbose     = options[:verbose]     if options[:verbose]
+      Matsuri::Config.debug       = options[:debug]       if options[:debug]
+      Matsuri::Config.environment = options[:environment] if options[:environment]
+    end
+  end
+end