conan_deploy_stackato3 0.1.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MTg4MDU5ODY5Y2YyMjQ3YmQ3YzU0M2E5ODc4MzUwZDY1NDQzMGVmNw==
+  data.tar.gz: !binary |-
+    OWM2YjNjMGYwYWMxYzE2NGU1NzZlZDJmZTM2NWE1YWE1ZDA5ZGIxNw==
+SHA512:
+  metadata.gz: !binary |-
+    YWQwNjA0OWNjMzJlYmFhYjNiZDM4ZTY3M2VjODc4M2FmYTU0ZmY1ZGY4MWQ3
+    MDE1NDJkZDc3Njc1Njk5NTAwNDg1NWEwYWY3ODg4M2VkYWUwNzUxNWZlYTI4
+    YWExNzQ5YmY2MmM2NWUzMDQxOGNiMzFhZTdkNmFhOTdjYzQzOTE=
+  data.tar.gz: !binary |-
+    NTE2NDg0N2I0NzY3YmNjMTZhMjM1NmQxZTg2YzJmOTlmNjJjNjdlN2FkOWFh
+    YWQ1NzkyMjQxMDNhZDNmN2E0MzQxZGNlNmQ4Y2YyOGYzYjJkZjRhZjE5Nzk5
+    NjlkOTJkOWQxNTM1MWJjZWUxNTQzMThkZjE2MGJhY2I2MjhlOTQ=

data/README.md

@@ -0,0 +1,223 @@
+conan
+=====
+
+Conan da Deployer
+
+This project provides automation for a [deployment pipeline](http://martinfowler.com/bliki/DeploymentPipeline.html) (ala 'Continous Delivery') which provisions, configures and deploys applications (Java and Ruby) to "ship-clouds". Configuration is modeled through a DSL as a list of logical target environments, each with a number of ship-clouds. Endpoints for web applications and Stackato PaaS APIs are created based on conventions, including support for [Blue/Green deployments](http://martinfowler.com/bliki/BlueGreenDeployment.html).
+
+Applications are deployed from a Sonotype Nexus artifact repository, and not from the source repository. Java applications must be executable jars, and must the provide deployment resources needed in the jar. Ruby apps (Rails or otherwise) must be vendored and packaged as a tar ball, with a compatible structrue to provide the deployment resources.
+
+Application artifacts are idenitifed and provisioned by Maven coordinates - group id, artifact id, packaging and version. The most recent version available on the repository will be used, or a promotion workflow along the pipeline(s) can be implemented by pinning the versions. Artifacts are pinned by keeping the build meta-data in an `environments` directory structure that mirrors the configuration model, which should be commited to version control after successful deployment and testing. _At this time, the `environments` directory and the `environments.rb` are located from the execution directory, which is assumed to be the [nexus-apps-manifest](https://github.com/MTNSatelliteComm/nexus-app-manifest) project._
+
+Conan is also designed to be idempotent. It can be executed against a target deployment over and over, and it should not change an application unless it out of alignment with the configuration model. Applications are also assumed to support standard set of managments APIs which provide build metadata, and health to support this.
+
+
+#Configuration
+
+Configuration for the deployment pipline is loaded through a DSL which models a target environment(s). The DSL is loaded from a `environments.rb` file that should be provided in the execution directory.  
+
+```ruby
+  pipeline(:'team1') {
+    app(:foo, 'com.mtnsat:foo', :jvm)
+    app(:bar,   'com.mtnsat:bar', :rails_zip)
+  }
+  pipeline(:'team2')
+    app(:baz,  'com.mtnsat:baz-web', :rails_zip)
+    app(:bang,  'com.mtnsat:bang', :rails_zip)
+  }
+
+  environment(:integ) {
+    org('mtn') {
+      deploy('aws') {
+        apps :foo
+      }
+      deploy('sea1') {
+        apps :foo, :bar
+        facility '999'
+      }
+      deploy('mia1') {
+        apps :foo, :bar, :baz
+        facility '888'
+      }
+    }
+  }  
+
+  environment(:prod) {
+    promotes_from :integ
+    org('mtn') {
+      deploy('aws') {
+        apps :foo
+      }
+    }
+    org('acme') {
+      deploy('minnow1') {
+        enabled false
+        apps :foo, :bar, :baz
+        facility '42'
+      }
+      deploy('minnow1') {
+        apps :bang
+        option 'mapping', 'acme-stuff.com'
+        option 'do-dad', 'flim-flam'
+      }
+      deploy('bounty1') {
+        apps :foo, :bar, :baz
+        facility '100'
+      }
+      deploy('bounty1') {
+        apps :bang
+        option 'mapping', 'acme-stuff.com'
+        option 'do-dad', 'woo-woo'
+      }
+    }
+  }
+```
+
+<dl>
+  <dt>pipeline</dt>
+  <dd>any number of application pipelines. Takes a symbol for the pipeline, and defines the apps that are delivered by that pipeline</dd>
+
+  <dt>app</dt>
+  <dd>any number of applications. Takes a symbol for the app, a maven group_id:artifact_id and the type of platform the app uses (:jvm or :rails_zip)</dd>
+
+  <dt>environment</dt>
+  <dd>any number of environments. takes a symbol for the environment, and any number of `deploy`s. NOTE: the order is _not_ significant.</dd>
+
+  <dt>promotes_from</dt>
+  <dd>a declaration to control what environment the provisioning uses to check for new versions to promote. The absence of this declartation means that the artifact repository will be checked for the latest version</dd>
+
+  <dt>org</dt>
+  <dd>scopes the deployment to the organization served by those deployments.</dd>
+
+  <dt>deploy</dt>
+  <dd>describes a deployment to the given ship-cloud. It takes a key for the ship, and some attributes</dd>
+  
+  <dt>endabled</dt>
+  <dd>deployments will be avoided if not 'true', default value is 'true' if absent</dd>
+  
+  <dt>apps</dt>
+  <dd>a list of symbols for applications (defined in `pipeline/app` above) which should be deployed to the environment</dd>
+  
+  <dt>facility</dt>
+  <dd>the facitility id</dd>
+
+  <dt>option</dt>
+  <dd>a way to define a key/value pair for deploy/app specific configurations (can be used multiple times to define N number key/value pairs)</dd>
+<dl>
+
+## Usage
+
+```
+$ conan [options] pipeline environment"
+
+   pipeline - name of the pipeline to use
+   environment - name of a the target environment: integ,stage,prod
+
+   Options:
+    -d, --output-dir [DIR]           Generate manifest data to this directory
+    -f, --output-format [FORMAT]     The format used to write output. Either "properties" for Jenkins build properties
+                                      or "stackato" (default) to provision binaries and write stackato yml files
+                                      from project templates.
+    -a, --action [ACTION]            The action(s) to perform. Either "provision" (default), "configure","deploy" or "all".
+                                      Support for blue/green deployments use actions: "provision", "bg_configure", "bg_deploy",
+                                      "bg_switch", "bg_clean" or "bg_all".
+    -u, --paas-user [USER]           The stackato user name for deployments
+    -p, --paas-password [PASSWORD]   The stackato password name for deployments
+    -F, --force-deploy               Force deployment to bypass version checks.
+    -N, --new-relic-api-key          New Relic API key for deployment alerts
+    -s [ORG-SHIP],                   Only include deployments for the given shipcloud (org-ship)
+        --deploy-shipcloud
+    -D, --dry-run                    Deployment dry-run. Prints Stackato commands
+    -V, --verbose                    Verbose console output
+    -v, --version                    Show the software version
+    -h, --help                       Display this screen
+
+
+```
+
+
+There are three phases...  provision, configure, deploy, The current pipeline only preforms the provision phase.
+
+1. provision:  Locate the binaries to deploy, download them from the artifact repository, and persist version information used to pin artifact versions and provides a workflow/promotion process. Version information (now really just the artifact meta-data from the artifact repository, instead of a properties file) is persisted in the `environments` directory tree.  Artifacts that are downloaded are staged for configuration and deployment in `tmp/apps`. Artifacts which are tar-balls are extracted in the staging directory. Projects should provide configuration templates in a `deploy-templates` directory (assuming that get's approval from the Rails crowd). For jar artifacts, it attempts to extract configuration templates from the jar, at `META-INF/deploy/templates` and puts them in the staging directory at the same `deploy-templates` location.
+
+2. configure:  Generate deployment-time configuration files from the model. It uses any ERB templates found at `deploy-templates` in the staging directory.  The templates generate files in the staging root directory, with the same name as the template, but the extension is removed. e.g. `stackato.yml.erb` -> `stackato.yml`
+
+3. deploy: Run Stackato deployment of the application staging directory.  It will avoid doing the deployment unless no service is found at the target hostname, the version check shows an older version running at the target hostname, or the `-F` flag forces deployment.
+
+_TBD: B/G actions_
+
+## Templates
+
+Templates for deloyment artifacts are .erb files (Erubis user guide: http://www.kuwata-lab.com/erubis/users-guide.html). 
+
+The templates are given a Context when it is evaluated. The Context provides the template with a set of key/values. The expected set of
+these is still maturing but here is an example of what is currently provided for a seanetsevice deployment, which has options defined:
+
+```
+app.artifact_id = "seanetservice"
+app.extension = 
+app.group_id = "com.mtnsat"
+app.id = foo
+app.platform_type = rails_zip
+app.sha1 = 
+app.version = 
+deploy.app_ids = [:foo]
+deploy.apps = []
+deploy.enabled? = true
+deploy.environment.deployments = [mtn-central, mtn-minnow1, mtn-minnow1, mtn-minnow1]
+deploy.environment.id = integ
+deploy.environment.upstream_env = 
+deploy.facility_id = "10007"
+deploy.shipcloud = "mtn-minnow1"
+deploy.options = {"mapping"=>["integ.example.com"], "network"=>["guest=1.1.1.10", "crew=1.1.1.91", "cloud=1.1.1.91"]}
+deploy.org = "mtn"
+deploy.ship = "minnow1"
+deploy_name = "foo-dev-minnow1"
+```
+
+App tokens for oauth are a special case, and assigned to special keys that will look something like:
+```
+oauth_id = application-gs8f8ae6-64a9-c987-c470-9c18b6fb918d
+oauth_secret = "4z3r6e779455d89db8896b3f4d8c2369ae71e9ca662abb366eea905a41de1dcf"
+```
+
+The are also a number of shortcuts provided for shorter keys:
+```
+app_id => app.id
+env => deploy.environment.id
+org => deploy.org
+ship => deploy.ship
+shipcloud => deploy.shipcloud
+infra => deploy.shipcloud
+facility => deploy.facility_id
+options => deploy.options
+```
+Warning: infra  will be removed at some point
+
+Here is an example Stackato template:
+```erb
+name: <%= @deploy_name %>
+instances: 1
+mem: 1G
+framework:
+  name: standalone
+  runtime: java7
+command: "java -Xms768m -Xmx768m -Dlog.logstash.source=\"${name}\" -Dlogback.configurationFile=logback-logstash.xml -jar poseidon.jar <%= @env %>"
+url:
+  - <%= @env %>.poseidon.<%= @ship %>.<%= @org %>.mtnsatcloud.com
+  - <%= @env %>.poseidon.mtnsatcloud.com
+min_version:
+  client: 1.4.3
+services:
+  ${name}-db: mysql
+```
+
+
+## Test
+
+$ bundle install
+$ bundle exec rspec
+
+To continously run specs when files are saved (or you hit return at the prompt):
+
+$ bundle exec guard

data/bin/conan-stackato3

@@ -0,0 +1,131 @@
+#!/usr/bin/env ruby
+require 'rest_client'
+require 'rexml/document'
+require 'json'
+require 'securerandom'
+require 'daphne_util'
+require 'optparse'
+require 'conan/application'
+require 'conan/application_helper'
+require 'conan/deploy'
+require 'conan/deployment'
+require 'conan/environment'
+require 'conan/has_options'
+require 'conan/jvm_app'
+require 'conan/manifest'
+require 'conan/manifest_builder'
+require 'conan/newrelic'
+require 'conan/options'
+require 'conan/output'
+require 'conan/pipeline'
+require 'conan/rails_zip_app'
+require 'conan/repository'
+require 'conan/stackato'
+require 'conan/templates'
+require 'conan/version'
+options = {}
+
+optparse = OptionParser.new do |o|
+  o.banner = "Usage: conan [options] pipeline environment"
+  o.separator ""
+  o.separator "   pipeline - name of the pipeline to use"
+  o.separator "   environment - name of a the target environment: integ,stage,prod"
+  o.separator ""
+  o.separator "   Options:"
+
+  o.on( '-d', '--output-dir [DIR]', 'Generate manifest data to this directory' ) do |dir|
+    options[:directory] = dir
+  end
+
+  o.on( '-f', '--output-format [FORMAT]', [:properties, :stackato],
+    'The format used to write output. Either "properties" for Jenkins build properties',
+    ' or "stackato" (default) to provision binaries and write stackato yml files',
+    ' from project templates.' ) do |format|
+    if (format)
+      options[:format] = format
+    else
+      puts "Unsupported --format option"
+      puts o
+      exit
+    end
+  end
+
+  o.on('-a','--action [ACTION]', [:provision,:configure,:deploy,:bg_configure,:bg_deploy,:all,:bg_all],
+    'The action(s) to perform. Either "provision" (default), "configure","deploy" or "all".',
+    ' Support for blue/green deployments use actions: "provision", "bg_configure", "bg_deploy",',
+    ' or "bg_all".') do |action|
+    if (action)
+      options[:action] = action
+    else
+      puts "Unsupported --action option"
+      puts o
+      exit
+    end
+  end
+
+  o.on('-u','--paas-user [USER]', 'The stackato user name for deployments' ) do |user|
+    options[:'paas-user'] = user
+  end
+
+  o.on('-p','--paas-password [PASSWORD]', 'The stackato password name for deployments' ) do |pw|
+    options[:'paas-password'] = pw
+  end
+
+  o.on('-S','--paas-space [SPACE]', 'The stackato space for deployments' ) do |space|
+    options[:'paas-space'] = space
+  end
+
+  o.on('-F','--force-deploy', 'Force deployment to bypass version checks.' ) do
+    options[:'force-deploy'] = true
+  end
+
+  o.on('-N', '--new-relic-api-key', 'New Relic API key for deployment alerts') do |api_key|
+    options[:'new-relic-api-key'] = api_key
+  end
+
+  o.on("-s", '--deploy-shipcloud [ORG-SHIP]', 'Only include deployments for the given shipcloud (org-ship)') do |shipcloud|
+    options[:'deploy-shipcloud'] = shipcloud
+  end
+
+  o.on("-n", '--deploy-app-name [APPNAME]', 'Only include deployments for the given application name') do |appname|
+    options[:'deploy-app-name'] = appname
+  end
+
+  o.on("-r", '--deploy-app-version [APPVERSION]', 'Only include deployments for the given application version') do |appversion|
+    options[:'deploy-app-version'] = appversion
+  end
+
+  o.on('-D','--dry-run', 'Deployment dry-run. Prints Stackato commands' ) do
+    options[:'dry-run'] = true
+  end
+
+  o.on("-v", "--version", "Show the software version") do
+   puts Conan::VERSION
+   exit
+  end
+
+  o.on_tail( '-h', '--help', 'Display this screen' ) do
+    puts o
+    exit
+  end
+end
+optparse.parse!
+
+
+if (ARGV.size < 1)
+    puts optparse
+    puts ''
+    raise ArgumentError, "No pipeline name argument was provided, e.g. nexus-apps-deploy"
+  else
+    options[:pipeline] = ARGV[0].downcase.to_sym
+  end
+
+if (ARGV.size < 2)
+    puts optparse
+    puts ''
+    raise ArgumentError, "No environment name argument was provided, e.g. integ"
+  else
+    options[:environment] = ARGV[1].downcase.to_sym
+  end
+
+Conan::Deploy.run(Conan::Options.new(options))

data/lib/conan/application.rb

@@ -0,0 +1,113 @@
+
+class Application
+
+  attr_accessor :id, :platform_type, :group_id, :artifact_id, :version, :extension, :sha1, :artifact_meta_data, :url_segment,
+  :org, :infra
+
+  def initialize(id, project_name, platform_type, options, url_segment=nil)
+    @id = id
+    @platform_type = platform_type
+    @url_segment = url_segment || id
+    mvn_id = project_name.split(':')
+    @options = options
+    @org = options[:'deploy-shipcloud'].split('-')[0]
+    @infra = options[:'deploy-shipcloud'].split('-')[1]
+    @environment = options[:environment]
+    @group_id = mvn_id[0]
+    @artifact_id = mvn_id[1]
+  end
+
+  def findRequestedVersion(requested_version='LATEST')
+    puts("Finding requested version: #{requested_version}")
+    extension = case platform_type
+      when :jvm
+        "jar"
+      when :rails_zip
+        "tar.gz"
+      else
+        raise "Unsupported platform type: #{platform_type}"
+      end
+    readArtifactMetadata(@artifact_repo.resolveArtifact(group_id, artifact_id, extension, requested_version))
+    puts "- Found version #{version} #{@id} artifact\n"+
+      "  Artifact: #{self}\n" +
+      "  Checksum: #{@sha1}"
+  end
+
+  def readArtifactMetadata(xml)
+    @artifact_meta_data = xml
+    begin
+      doc = REXML::Document.new(xml)
+    rescue Exception => e
+      puts "Failed to parse meta-data: #{e}"
+      puts "--------------------------------"
+      puts xml
+      puts "--------------------------------"
+      raise "Unreadable artifact meta-data for #{self}"
+    end
+
+    meta_data = doc.elements['/artifact-resolution/data']
+    @version = meta_data.elements['version'].text
+    @sha1 = meta_data.elements['sha1'].text
+    @extension = meta_data.elements['extension'].text
+  end
+
+  def download(location)
+    puts "- Provision #{group_id}:#{artifact_id}:#{extension}:#{version}"
+    @artifact_repo.downloadArtifact(location, group_id, artifact_id, extension, version, sha1)
+  end
+
+  def isDeployedAt(url)
+    # only deploy if an older version is found, or no app found
+    res = false
+    begin
+      response = RestClient::Request.new(
+        :method => :get,
+        :url => url,
+        :headers => {
+          'accept' => :json,
+          'content_type' => :json
+        },
+        :timeout => 5,
+        :open_timeout => 5
+      ).execute
+      if (response.code == 200)
+        build_metadata = JSON.parse(response.to_str)
+        puts ''
+        puts "+- Currently at #{url}:"
+        printM = ->(s) {
+          puts " | #{s}: #{build_metadata[s]}"
+        }
+        printM.call 'Implementation-Title'
+        printM.call 'Build-Version'
+        printM.call 'Build-Url'
+        printM.call 'Git-Commit'
+        current_ver = build_metadata["Build-Version"]
+      end
+      #TODO make sure the artifact id matches too, currently finding  "Implementation-Title": "apollo" in build metadata
+      if (compareVersion(@version, current_ver))
+        puts "#{@artifact_id} #{@version} is newer than version found at #{url}: #{current_ver}"
+      else
+        puts "#{@artifact_id} #{@version} found at #{url}. (skipping deployment)"
+        res = true
+      end
+    rescue => e
+      puts "#{@artifact_id} not found at #{url}: #{e}"
+    end
+    res
+  end
+
+  def compareVersion(target_version, deployed_version)
+    target = Gem::Version.new(target_version)
+    begin
+      found = Gem::Version.new(deployed_version)
+      target > found
+    rescue => e
+      puts "Error parsing version number: #{e}"
+      false
+    end
+  end
+
+  def to_s
+    "#{artifact_id}-#{version}.#{extension}"
+  end
+end

data/lib/conan/application_helper.rb

@@ -0,0 +1,120 @@
+require 'rest_client'
+require 'json'
+require 'ostruct'
+
+module RestClientExt
+  include RestClient
+
+  RETRIES = 3
+
+  def self.handle_network_error(verb, err, url, tries)
+    additional_tries = tries - 1
+    message = "#{verb} to #{url} failed with (#{err.ai}), retrying #{additional_tries} more times"
+
+    case err
+      when Errno::ETIMEDOUT, Errno::ECONNREFUSED, RestClient::ServerBrokeConnection, RestClient::RequestTimeout
+        puts message
+        sleep 1
+      else
+        raise err
+    end
+
+    additional_tries
+  end
+
+  def self.request_options(verb, url, headers, payload = nil)
+    opts = {
+        :method => verb.downcase.to_sym,
+        :url => url,
+        :headers => headers.clone,
+        :timeout => headers[:timeout] || 10,
+        :open_timeout => headers[:open_timeout] || 10
+    }
+
+    payload ? opts.merge(:payload => payload) : opts
+  end
+
+  def self.execute_request(verb, url, headers, payload = nil, tries = RETRIES, &block)
+    Request.execute(request_options(verb, url, headers, payload),&block)
+  rescue SystemCallError, Exception => err
+    retry unless (tries = handle_network_error(verb, err, url, tries)).zero?
+  end
+
+  def self.get(url, headers={}, &block)
+    execute_request("GET", url, headers, &block)
+  end
+
+  def self.post(url, payload, headers={}, &block)
+    execute_request("POST", url, headers, payload, &block)
+  end
+
+  def self.put(url, payload, headers={}, &block)
+    execute_request("PUT", url, headers, payload, &block)
+  end
+
+  def self.delete(url, headers={}, &block)
+    execute_request("DELETE", url, headers, &block)
+  end
+end
+
+module ApiHelper
+
+  def self.defaultHeaders(headers = {})
+    default_headers = {
+        :user_agent => 'CONAN_DA_DEPLOYER',
+        :accept => :json,
+        :accept_encoding => :gzip,
+        :content_type => :json }
+
+    default_headers = default_headers.merge(headers).delete_if { |k, v| v.nil? }
+    return default_headers
+  end
+
+  def self.smoke_test(url, timeout)
+    puts "Smoke Testing #{url}"
+    RestClientExt.get(
+        url,
+        defaultHeaders(
+            :timeout => timeout,
+            :open_timeout => timeout)) do |response, request, result, &block|
+      return NexusResponse.new(response.code, response.body)
+    end
+  end
+end
+
+class NexusResponse
+  attr_accessor :code
+  attr_accessor :json
+  attr_accessor :raw_json
+
+  def initialize(code, raw_json)
+    @code = code
+
+    begin
+      @json = OpenStruct.new(JSON.parse(Zlib::GzipReader.new(StringIO.new(raw_json)).read))
+      @raw_json = Zlib::GzipReader.new(StringIO.new(raw_json)).read
+    rescue Zlib::Error
+      begin
+        @json = OpenStruct.new(JSON.parse(raw_json))
+        @raw_json = raw_json
+      rescue JSON::ParserError
+        puts "NexusResponse - could not parse following JSON:\n#{raw_json}"
+        @json = OpenStruct.new(JSON.parse("{ \"status\" : \"error\", \"errorMessage\" : \"Previous call likely returned a Stackato HTML error page\" }"))
+        @raw_json = raw_json
+      end
+    rescue Zlib::GzipFile::Error
+      begin
+        @json = OpenStruct.new(JSON.parse(raw_json))
+        @raw_json = raw_json
+      rescue JSON::ParserError
+        puts "NexusResponse - could not parse following JSON:\n#{raw_json}"
+        @json = OpenStruct.new(JSON.parse("{ \"status\" : \"error\", \"errorMessage\" : \"Previous call likely returned a Stackato HTML error page\" }"))
+        @raw_json = raw_json
+      end
+    rescue JSON::ParserError
+      puts "NexusResponse - could not parse following JSON:\n#{raw_json}"
+      @json = OpenStruct.new(JSON.parse("{ \"status\" : \"error\", \"errorMessage\" : \"Previous call likely returned a Stackato HTML error page\" }"))
+      @raw_json = raw_json
+    end
+  end
+end

data/lib/conan/deploy.rb

@@ -0,0 +1,41 @@
+require 'conan/manifest_builder'
+require 'optparse'
+
+module Conan
+  class Deploy
+    def self.run(options)
+      puts "> Pipeline: #{options[:pipeline]}"
+      puts "> Environment: #{options[:environment]}"
+
+      manifest = ManifestBuilder.build(options) {
+        m = File.join(options[:directory], 'environments.rb')
+        puts "> Manifest: #{m}"
+        instance_eval(File.read(m), m)
+      }
+
+      case options[:action]
+      when :provision
+        manifest.provision
+      when :configure
+        manifest.configure
+      when :deploy
+        manifest.deploy
+      when :bg_configure
+        manifest.bg_configure
+      when :bg_deploy
+        manifest.bg_deploy
+      when :all
+        manifest.provision
+        manifest.configure
+        manifest.deploy
+      when :bg_all
+        manifest.provision
+        manifest.bg_configure
+        manifest.bg_deploy
+
+      else
+        raise ArgumentError.new "Invalid action: #{options[:action]}"
+      end
+    end
+  end
+end