sensu 0.7.0-x86-mingw32 → 0.7.1-x86-mingw32

data/Gemfile.lock

@@ -1,11 +1,12 @@
 PATH
   remote: .
   specs:
-    sensu (0.6.7)
+    sensu (0.7.0)
       amqp (= 0.7.4)
       async_sinatra
       em-hiredis
       em-syslog
+      hashie
       json
       thin
       uuidtools
@@ -29,6 +30,7 @@ GEM
       callsite (~> 0.0.5)
       eventmachine
     eventmachine (0.12.10)
+    hashie (1.1.0)
     hiredis (0.3.2)
     json (1.6.1)
     mime-types (1.16)

data/lib/sensu/client.rb

@@ -23,69 +23,78 @@ module Sensu
     def initialize(options={})
       config = Sensu::Config.new(:config_file => options[:config_file])
       @settings = config.settings
-      @checks_in_progress = Array.new
     end
 
     def setup_amqp
-      connection = AMQP.connect(symbolize_keys(@settings['rabbitmq']))
+      connection = AMQP.connect(@settings.rabbitmq.to_hash.symbolize_keys)
       @amq = MQ.new(connection)
-      @keepalive_queue = @amq.queue('keepalives')
-      @result_queue = @amq.queue('results')
     end
 
     def setup_keepalives
-      @keepalive_queue.publish(@settings['client'].merge({'timestamp' => Time.now.to_i}).to_json)
+      keepalive_queue = @amq.queue('keepalives')
+      @settings.client.timestamp = Time.now.to_i
+      keepalive_queue.publish(@settings.client.to_json)
       EM.add_periodic_timer(30) do
-        @keepalive_queue.publish(@settings['client'].merge({'timestamp' => Time.now.to_i}).to_json)
+        @settings.client.timestamp = Time.now.to_i
+        keepalive_queue.publish(@settings.client.to_json)
       end
     end
 
+    def publish_result(check)
+      @result_queue ||= @amq.queue('results')
+      @result_queue.publish({
+        :client => @settings.client.name,
+        :check => check.to_hash
+      }.to_json)
+    end
+
     def execute_check(check)
-      result = {'client' => @settings['client']['name'], 'check' => check}
-      if @settings['checks'].has_key?(check['name'])
-        unless @checks_in_progress.include?(check['name'])
-          @checks_in_progress.push(check['name'])
+      @checks_in_progress ||= Array.new
+      if @settings.checks.key?(check.name)
+        unless @checks_in_progress.include?(check.name)
+          @checks_in_progress.push(check.name)
           unmatched_tokens = Array.new
-          command = @settings['checks'][check['name']]['command'].gsub(/:::(.*?):::/) do
+          command = @settings.checks[check.name].command.gsub(/:::(.*?):::/) do
             key = $1.to_s
-            unmatched_tokens.push(key) unless @settings['client'].has_key?(key)
-            @settings['client'][key].to_s
+            unmatched_tokens.push(key) unless @settings.client.key?(key)
+            @settings.client[key].to_s
           end
           if unmatched_tokens.empty?
             execute = proc do
               IO.popen(command + ' 2>&1') do |io|
-                result['check']['output'] = io.read
+                check.output = io.read
               end
-              result['check']['status'] = $?.exitstatus
-              result
+              check.status = $?.exitstatus
             end
             publish = proc do |result|
-              @result_queue.publish(result.to_json)
-              @checks_in_progress.delete(result['check']['name'])
+              publish_result(check)
+              @checks_in_progress.delete(check.name)
             end
             EM.defer(execute, publish)
           else
-            result['check']['status'] = 3
-            result['check']['output'] = 'Missing client attributes: ' + unmatched_tokens.join(', ')
-            @result_queue.publish(result.to_json)
-            @checks_in_progress.delete(check['name'])
+            check.status = 3
+            check.output = 'Missing client attributes: ' + unmatched_tokens.join(', ')
+            check.internal = true
+            publish_result(check)
+            @checks_in_progress.delete(check.name)
           end
         end
       else
-        result['check']['status'] = 3
-        result['check']['output'] = 'Unknown check'
-        @result_queue.publish(result.to_json)
-        @checks_in_progress.delete(check['name'])
+        check.status = 3
+        check.output = 'Unknown check'
+        check.internal = true
+        publish_result(check)
+        @checks_in_progress.delete(check.name)
       end
     end
 
     def setup_subscriptions
       @check_queue = @amq.queue(UUIDTools::UUID.random_create.to_s, :exclusive => true)
-      @settings['client']['subscriptions'].each do |exchange|
+      @settings.client.subscriptions.each do |exchange|
         @check_queue.bind(@amq.fanout(exchange))
       end
       @check_queue.subscribe do |check_json|
-        check = JSON.parse(check_json)
+        check = Hashie::Mash.new(JSON.parse(check_json))
         execute_check(check)
       end
     end

data/lib/sensu/config.rb

@@ -1,6 +1,7 @@
 require 'rubygems' if RUBY_VERSION < '1.9.0'
 require 'optparse'
 require 'json'
+require 'hashie'
 require 'uuidtools'
 require 'amqp'
 require 'em/syslog'
@@ -12,29 +13,29 @@ module Sensu
 
     def initialize(options={})
       config_file = options[:config_file] || '/etc/sensu/config.json'
-      @settings = JSON.parse(File.open(config_file, 'r').read)
+      @settings = Hashie::Mash.new(JSON.parse(File.open(config_file, 'r').read))
       validate_config
     end
 
     def validate_config
-      @settings['checks'].each do |name, info|
-        unless info['interval'].is_a?(Integer) && info['interval'] > 0
+      @settings.checks.each do |name, details|
+        unless details.interval.is_a?(Integer) && details.interval > 0
           raise 'configuration invalid, missing interval for check ' + name
         end
-        unless info['command'].is_a?(String)
+        unless details.command.is_a?(String)
           raise 'configuration invalid, missing command for check ' + name
         end
-        unless info['subscribers'].is_a?(Array) && info['subscribers'].count > 0
+        unless details.subscribers.is_a?(Array) && details.subscribers.count > 0
           raise 'configuration invalid, missing subscribers for check ' + name
         end
       end
-      unless @settings['client']['name'].is_a?(String)
+      unless @settings.client.name.is_a?(String)
         raise 'configuration invalid, client must have a name'
       end
-      unless @settings['client']['address'].is_a?(String)
+      unless @settings.client.address.is_a?(String)
         raise 'configuration invalid, client must have an address (ip or hostname)'
       end
-      unless @settings['client']['subscriptions'].is_a?(Array) && @settings['client']['subscriptions'].count > 0
+      unless @settings.client.subscriptions.is_a?(Array) && @settings.client.subscriptions.count > 0
         raise 'configuration invalid, client must have subscriptions'
       end
     end
@@ -46,9 +47,12 @@ module Sensu
           puts opts
           exit
         end
-        options[:worker] = false
-        opts.on('-w', '--worker', 'Only consume jobs, no check publishing (default: false)') do
-          options[:worker] = true
+        current_process = $0.split('/').last
+        if current_process == 'sensu-server' || current_process == 'rake_test_loader.rb'
+          options[:worker] = false
+          opts.on('-w', '--worker', 'Only consume jobs, no check publishing (default: false)') do
+            options[:worker] = true
+          end
         end
         options[:config_file] = nil
         opts.on('-c', '--config FILE', 'Sensu JSON config FILE (default: /etc/sensu/config.json)') do |file|

data/lib/sensu/helpers.rb

@@ -1,18 +1,20 @@
-def symbolize_keys(item)
-  case item
-  when Array
-    item.map do |i|
-      symbolize_keys(i)
+class Hash
+  def symbolize_keys(item = self)
+    case item
+    when Array
+      item.map do |i|
+        symbolize_keys(i)
+      end
+    when Hash
+      Hash[
+        item.map do |key, value|
+          new_key = key.is_a?(String) ? key.to_sym : key
+          new_value = symbolize_keys(value)
+          [new_key, new_value]
+        end
+      ]
+    else
+      item
     end
-  when Hash
-    Hash[
-          item.map do |key, value|
-            k = key.is_a?(String) ? key.to_sym : key
-            v = symbolize_keys(value)
-            [k,v]
-          end
-        ]
-  else
-    item
   end
 end

data/lib/sensu.rb

@@ -1,3 +1,3 @@
 module Sensu
-  VERSION = "0.7.0"
+  VERSION = "0.7.1"
 end

data/sensu.gemspec

@@ -14,6 +14,7 @@ Gem::Specification.new do |s|
 
   s.add_dependency("amqp", "0.7.4")
   s.add_dependency("json")
+  s.add_dependency("hashie")
   s.add_dependency("uuidtools")
   s.add_dependency("em-syslog")
   s.add_dependency("em-hiredis")
@@ -25,7 +26,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency('em-ventually')
   s.add_development_dependency('rest-client')
 
-  s.files         = `git ls-files`.split("\n").reject {|f| f =~ /(dist|test)/}
+  s.files         = `git ls-files`.split("\n").reject {|f| f =~ /(dist|test|png)/}
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 end

data/sensu.windows

@@ -21,10 +21,11 @@ Gem::Specification.new do |s|
   s.add_dependency("eventmachine", "1.0.0.beta.4.1")
   s.add_dependency("amqp", "0.7.4")
   s.add_dependency("json")
+  s.add_dependency("hashie")
   s.add_dependency("uuidtools")
   s.add_dependency("em-syslog")
 
-  s.files         = `git ls-files`.split("\n").reject {|f| f =~ /(dist|test)/}
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.files         = `git ls-files`.split("\n").reject {|f| f =~ /(dist|test|server|api|png)/}
+  s.executables   = "sensu-client"
   s.require_paths = ["lib"]
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: sensu
 version: !ruby/object:Gem::Version 
-  hash: 3
+  hash: 1
   prerelease: false
   segments: 
   - 0
   - 7
-  - 0
-  version: 0.7.0
+  - 1
+  version: 0.7.1
 platform: x86-mingw32
 authors: 
 - Sean Porter
@@ -69,7 +69,7 @@ dependencies:
   type: :runtime
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
-  name: uuidtools
+  name: hashie
   prerelease: false
   requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
@@ -83,7 +83,7 @@ dependencies:
   type: :runtime
   version_requirements: *id004
 - !ruby/object:Gem::Dependency 
-  name: em-syslog
+  name: uuidtools
   prerelease: false
   requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
@@ -96,14 +96,26 @@ dependencies:
         version: "0"
   type: :runtime
   version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: em-syslog
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id006
 description: A server monitoring framework using the publish-subscribe model
 email: 
 - sean.porter@sonian.net
 - justin.kolberg@sonian.net
 executables: 
-- sensu-api
 - sensu-client
-- sensu-server
 extensions: []
 
 extra_rdoc_files: []
@@ -115,16 +127,11 @@ files:
 - MIT-LICENSE.txt
 - README.org
 - Rakefile
-- bin/sensu-api
 - bin/sensu-client
-- bin/sensu-server
 - lib/sensu.rb
-- lib/sensu/api.rb
 - lib/sensu/client.rb
 - lib/sensu/config.rb
 - lib/sensu/helpers.rb
-- lib/sensu/server.rb
-- sensu-logo.png
 - sensu.gemspec
 - sensu.windows
 has_rdoc: true

data/bin/sensu-api

@@ -1,9 +0,0 @@
-#!/usr/bin/env ruby
-
-raise "The Sensu API does not run on Windows" if RUBY_PLATFORM.downcase =~ /mswin|mingw32|windows/
-
-$: << File.dirname(__FILE__) + '/../lib' unless $:.include?(File.dirname(__FILE__) + '/../lib/')
-require 'sensu/api'
-
-options = Sensu::Config.read_arguments(ARGV)
-Sensu::API.run(options)

data/bin/sensu-server

@@ -1,9 +0,0 @@
-#!/usr/bin/env ruby
-
-raise "The Sensu Server does not run on Windows" if RUBY_PLATFORM.downcase =~ /mswin|mingw32|windows/
-
-$: << File.dirname(__FILE__) + '/../lib' unless $:.include?(File.dirname(__FILE__) + '/../lib/')
-require 'sensu/server'
-
-options = Sensu::Config.read_arguments(ARGV)
-Sensu::Server.run(options)

data/lib/sensu/api.rb

@@ -1,173 +0,0 @@
-require File.join(File.dirname(__FILE__), 'config')
-require 'sinatra/async'
-require 'em-hiredis'
-
-module Sensu
-  class API < Sinatra::Base
-    register Sinatra::Async
-
-    def self.run(options={})
-      EM.run do
-        self.setup(options)
-        self.run!(:port => @settings['api']['port'])
-
-        Signal.trap('INT') do
-          EM.stop
-        end
-
-        Signal.trap('TERM') do
-          EM.stop
-        end
-      end
-    end
-
-    def self.setup(options={})
-      config = Sensu::Config.new(options)
-      @settings = config.settings
-      set :redis, EM::Hiredis.connect('redis://' + @settings['redis']['host'] + ':' + @settings['redis']['port'].to_s)
-      connection = AMQP.connect(symbolize_keys(@settings['rabbitmq']))
-      set :amq, MQ.new(connection)
-    end
-
-    helpers do
-      include Rack::Utils
-      alias_method :conn, :settings
-    end
-
-    before do
-      content_type 'application/json'
-    end
-
-    aget '/clients' do
-      current_clients = Array.new
-      conn.redis.smembers('clients').callback do |clients|
-        unless clients.empty?
-          clients.each_with_index do |client, index|
-            conn.redis.get('client:' + client).callback do |client_json|
-              current_clients.push(JSON.parse(client_json))
-              body current_clients.to_json if index == clients.size-1
-            end
-          end
-        else
-          body current_clients.to_json
-        end
-      end
-    end
-
-    aget '/client/:name' do |client|
-      conn.redis.get('client:' + client).callback do |client_json|
-        status 404 if client_json.nil?
-        body client_json
-      end
-    end
-
-    adelete '/client/:name' do |client|
-      conn.redis.sismember('clients', client).callback do |client_exists|
-        unless client_exists == 0
-          conn.redis.exists('events:' + client).callback do |events_exist|
-            unless events_exist == 0
-              conn.redis.hgetall('events:' + client).callback do |events|
-                Hash[*events].keys.each do |check_name|
-                  check = {'name' => check_name, 'issued' => Time.now.to_i, 'status' => 0, 'output' => 'Client is being removed'}
-                  conn.amq.queue('results').publish({'client' => client, 'check' => check}.to_json)
-                end
-                EM.add_timer(5) do
-                  conn.redis.srem('clients', client)
-                  conn.redis.del('events:' + client)
-                  conn.redis.del('client:' + client)
-                end
-              end
-            else
-              conn.redis.srem('clients', client)
-              conn.redis.del('events:' + client)
-              conn.redis.del('client:' + client)
-            end
-            status 204
-            body nil
-          end
-        else
-          status 404
-          body nil
-        end
-      end
-    end
-
-    aget '/event/:client/:check' do |client, check|
-      conn.redis.hgetall('events:' + client).callback do |events|
-        client_events = Hash[*events]
-        event = client_events[check]
-        status 404 if event.nil?
-        body event
-      end
-    end
-
-    aget '/events' do
-      current_events = Hash.new
-      conn.redis.smembers('clients').callback do |clients|
-        unless clients.empty?
-          clients.each_with_index do |client, index|
-            conn.redis.hgetall('events:' + client).callback do |events|
-              client_events = Hash[*events]
-              client_events.each do |key, value|
-                client_events[key] = JSON.parse(value)
-              end
-              current_events[client] = client_events unless client_events.empty?
-              body current_events.to_json if index == clients.size-1
-            end
-          end
-        else
-          body current_events.to_json
-        end
-      end
-    end
-
-    apost '/stash/*' do |path|
-      conn.redis.set('stash:' + path, request.body.read).callback do
-        status 201
-        body nil
-      end
-    end
-
-    aget '/stash/*' do |path|
-      conn.redis.get('stash:' + path).callback do |stash|
-        status 404 if stash.nil?
-        body stash
-      end
-    end
-
-    adelete '/stash/*' do |path|
-      conn.redis.exists('stash:' + path).callback do |stash_exist|
-        unless stash_exist == 0
-          conn.redis.del('stash:' + path).callback do
-            status 204
-            body nil
-          end
-        else
-          status 404
-          body nil
-        end
-      end
-    end
-
-    apost '/test' do
-      client = '{
-        "name": "test",
-        "address": "localhost",
-        "subscriptions": [
-          "foo",
-          "bar"
-        ]
-      }'
-      conn.redis.set('client:test', client).callback do
-        conn.redis.sadd('clients', 'test').callback do
-          conn.redis.hset('events:test', 'test', {'status' => 2, 'output' => 'CRITICAL', 'occurrences' => 1}.to_json).callback do
-            conn.redis.set('stash:test/test', '{"key": "value"}').callback do
-              status 201
-              body nil
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/sensu/server.rb

@@ -1,226 +0,0 @@
-require File.join(File.dirname(__FILE__), 'config')
-require 'em-hiredis'
-
-module Sensu
-  class Server
-    attr_accessor :redis, :is_worker
-    alias :redis_connection :redis
-
-    def self.run(options={})
-      EM.threadpool_size = 15
-      EM.run do
-        server = self.new(options)
-        server.setup_logging
-        server.setup_redis
-        server.setup_amqp
-        server.setup_keepalives
-        server.setup_results
-        unless server.is_worker
-          server.setup_publisher
-          server.setup_keepalive_monitor
-        end
-        server.setup_queue_monitor
-
-        Signal.trap('INT') do
-          EM.stop
-        end
-
-        Signal.trap('TERM') do
-          EM.stop
-        end
-      end
-    end
-
-    def initialize(options={})
-      config = Sensu::Config.new(:config_file => options[:config_file])
-      @settings = config.settings
-      @is_worker = options[:worker]
-    end
-
-    def setup_logging
-      EM.syslog_setup(@settings['syslog']['host'], @settings['syslog']['port'])
-    end
-
-    def setup_redis
-      @redis = EM::Hiredis.connect('redis://' + @settings['redis']['host'] + ':' + @settings['redis']['port'].to_s)
-    end
-
-    def setup_amqp
-      connection = AMQP.connect(symbolize_keys(@settings['rabbitmq']))
-      @amq = MQ.new(connection)
-    end
-
-    def setup_keepalives
-      @keepalive_queue = @amq.queue('keepalives')
-      @keepalive_queue.subscribe do |keepalive_json|
-        client = JSON.parse(keepalive_json)['name']
-        @redis.set('client:' + client, keepalive_json).callback do
-          @redis.sadd('clients', client)
-        end
-      end
-    end
-
-    def handle_event(event)
-      handler = proc do
-        output = ''
-        IO.popen(@settings['handlers'][event['check']['handler']] + ' 2>&1', 'r+') do |io|
-          io.write(event.to_json)
-          io.close_write
-          output = io.read
-        end
-        output
-      end
-      report = proc do |output|
-        output.split(/\n+/).each do |line|
-          EM.debug(line)
-        end
-      end
-      EM.defer(handler, report)
-    end
-
-    def process_result(result)
-      @redis.get('client:' + result['client']).callback do |client_json|
-        unless client_json.nil?
-          client = JSON.parse(client_json)
-          check = result['check']
-          if @settings['checks'][check['name']]
-            check.merge!(@settings['checks'][check['name']])
-          end
-          check['handler'] ||= 'default'
-          event = {'client' => client, 'check' => check, 'occurrences' => 1}
-          if check['type'] == 'metric'
-            handle_event(event)
-          else
-            history_key = 'history:' + client['name'] + ':' + check['name']
-            @redis.rpush(history_key, check['status']).callback do
-              @redis.lrange(history_key, -21, -1).callback do |history|
-                total_state_change = 0
-                unless history.count < 21
-                  state_changes = 0
-                  change_weight = 0.8
-                  history.each do |status|
-                    previous_status ||= status
-                    unless status == previous_status
-                      state_changes += change_weight
-                    end
-                    change_weight += 0.02
-                    previous_status = status
-                  end
-                  total_state_change = (state_changes.fdiv(20) * 100).to_i
-                  @redis.lpop(history_key)
-                end
-                high_flap_threshold = check['high_flap_threshold'] || 50
-                low_flap_threshold = check['low_flap_threshold'] || 40
-                @redis.hget('events:' + client['name'], check['name']).callback do |event_json|
-                  previous_event = event_json ? JSON.parse(event_json) : false
-                  flapping = previous_event ? previous_event['flapping'] : false
-                  check['flapping'] = case
-                  when total_state_change >= high_flap_threshold
-                    true
-                  when flapping && total_state_change <= low_flap_threshold
-                    false
-                  else
-                    flapping
-                  end
-                  if previous_event && check['status'] == 0
-                    unless check['flapping']
-                      @redis.hdel('events:' + client['name'], check['name']).callback do
-                        event['action'] = 'resolve'
-                        handle_event(event)
-                      end
-                    else
-                      @redis.hset('events:' + client['name'], check['name'], previous_event.merge({'flapping' => true}).to_json)
-                    end
-                  elsif check['status'] != 0
-                    if previous_event && check['status'] == previous_event['status']
-                      event['occurrences'] = previous_event['occurrences'] += 1
-                    end
-                    @redis.hset('events:' + client['name'], check['name'], {
-                      'status' => check['status'],
-                      'output' => check['output'],
-                      'flapping' => check['flapping'],
-                      'occurrences' => event['occurrences']
-                    }.to_json).callback do
-                      event['action'] = 'create'
-                      handle_event(event)
-                    end
-                  end
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-
-    def setup_results
-      @result_queue = @amq.queue('results')
-      @result_queue.subscribe do |result_json|
-        result = JSON.parse(result_json)
-        process_result(result)
-      end
-    end
-
-    def setup_publisher(options={})
-      exchanges = Hash.new
-      stagger = options[:test] ? 0 : 7
-      @settings['checks'].each_with_index do |(name, details), index|
-        EM.add_timer(stagger*index) do
-          details['subscribers'].each do |exchange|
-            if exchanges[exchange].nil?
-              exchanges[exchange] = @amq.fanout(exchange)
-            end
-            interval = options[:test] ? 0.5 : details['interval']
-            EM.add_periodic_timer(interval) do
-              exchanges[exchange].publish({'name' => name, 'issued' => Time.now.to_i}.to_json)
-              EM.debug('name="Published Check" event_id=server action="Published check ' + name + ' to the ' + exchange + ' exchange"')
-            end
-          end
-        end
-      end
-    end
-
-    def setup_keepalive_monitor
-      EM.add_periodic_timer(30) do
-        @redis.smembers('clients').callback do |clients|
-          clients.each do |client_id|
-            @redis.get('client:' + client_id).callback do |client_json|
-              client = JSON.parse(client_json)
-              time_since_last_check = Time.now.to_i - client['timestamp']
-              result = {'client' => client['name'], 'check' => {'name' => 'keepalive', 'issued' => Time.now.to_i}}
-              case
-              when time_since_last_check >= 180
-                result['check']['status'] = 2
-                result['check']['output'] = 'No keep-alive sent from host in over 180 seconds'
-                process_result(result)
-              when time_since_last_check >= 120
-                result['check']['status'] = 1
-                result['check']['output'] = 'No keep-alive sent from host in over 120 seconds'
-                process_result(result)
-              else
-                @redis.hexists('events:' + client_id, 'keepalive').callback do |exists|
-                  if exists == 1
-                    result['check']['status'] = 0
-                    result['check']['output'] = 'Keep-alive sent from host'
-                    process_result(result)
-                  end
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-
-    def setup_queue_monitor
-      EM.add_periodic_timer(5) do
-        unless @keepalive_queue.subscribed?
-          setup_keepalives
-        end
-        unless @result_queue.subscribed?
-          setup_results
-        end
-      end
-    end
-  end
-end