outoftime-shell_elf 0.9.0

data/README.rdoc

@@ -0,0 +1,116 @@
+= Shell Elf
+
+http://github.com/outoftime/shell_elf
+
+Shell Elf is a small, standalone daemon whose sole purpose is to read shell
+commands out of a Starling queue, execute them, and optionally POST back to an
+HTTP service on success or failure. Shell Elf is distributed as a RubyGem, but
+is not meant to be included as a library; rather, it contains the standalone
+`shell-elf` executable, which starts and stops the daemon.
+
+Features
+
+* Send a single shell command or a batch of commands to be executed serially
+* Specify postback URLs for success and failure, so that your application can
+  be notified when batch has completed.
+* Gracefully catch TERM and INT signals, either finishing the current batch or
+  requeueing it for later processing before exiting.
+
+== Usage
+
+=== Installation
+
+  sudo gem install outoftime-shell_elf --source=gems.github.com
+  
+=== Starting the daemon
+
+  shell-elf start -- [options]
+
+The following options are available; none are required:
+
+[-q/--queue] name of the Starling queue to read from (default: shell_elf)
+[-h/--host] hostname at which the Starling daemon is running (default: localhost)
+[-p/--port] port on which the Starling daemon is listening (default: 22122)
+[--log-file] full path to a log file (default: no logging)
+[--log-level] level at which to log (default: WARN)
+
+=== Stopping the daemon
+
+  shell-elf stop
+
+=== Sending commands from your application
+
+  require 'rubygems'
+  gem 'starling-starling'
+  require 'starling'
+
+  starling = Starling.new('localhost:22122')
+
+  # send the single command `touch /tmp/hey`
+  starling.set('shell_elf', :command => ['touch', '/tmp/hey'])
+
+  # send the two commands `touch /tmp/one` followed by `touch /tmp/2`
+  starling.set('shell_elf', :commands => [['touch', '/tmp/one'], ['touch', '/tmp/two']])
+
+  # send a command with success/failure postbacks
+  starling.set('shell_elf', :command => ['touch', '/tmp/hey'],
+                            :options => { :success => { 'http://localhost:3000/command/success' },
+                                        { :failure => { 'http://localhost:3000/command/failure' }})
+
+  # send a command with instructions to requeue if the daemon is interrupted
+  starling.set('shell_elf', :command => ['sleep', '120'],
+                            :options => { :on_interrupt => :requeue })
+  
+=== A note about batches and postbacks
+
+If the postbacks are specified (you can specify neither, either, or both),
+ShellElf will send an HTTP POST request to the specified URL. The batch is
+considered successful if all of the commands exit with a status code of 0. If
+one of the commands in the batch exits with a non-zero status code, *the
+rest of the commands in the batch are not run*, and the failure postback will
+be sent. ShellElf waits until the postback request completes before retrieving
+the next batch from the queue.
+
+== The ShellElf Client
+
+...doesn't exist. I'm a big fan of libraries presenting intuitive APIs to the
+application layer, but in this case a general-purpose client would be so
+trivial that it doesn't seem worth writing one. Further, I assume that in the
+general use case, applications will want to build task-specific APIs that wrap
+the task of shelling out via Starling. Having a further layer of abstraction
+doesn't seem to add much value.
+
+== Dependencies
+
+* escape
+* starling-starling
+* daemons
+* choice
+
+== Contact and Futher Reading
+
+Contact: Mat Brown <mat@patch.com>
+Further Reading: http://outofti.me/tagged/shell_elf
+
+== The MIT License
+
+Copyright (c) 2009 Mat Brown
+
+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/Rakefile

@@ -0,0 +1,7 @@
+require 'rubygems'
+
+ENV['RUBYOPT'] = '-W1'
+
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+task :default => :spec

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:minor: 9
+:patch: 0
+:major: 0

data/bin/shell-elf

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+gem 'daemons'
+require 'tmpdir'
+require 'daemons'
+
+Daemons.run(File.join(File.dirname(File.dirname(__FILE__)), 'script', 'shell-elf-listener'),
+            :dir_mode => :normal,
+            :dir => Dir.tmpdir)

data/lib/shell_elf/batch.rb

@@ -0,0 +1,41 @@
+module ShellElf
+  class Batch
+    class <<self
+      def execute(params)
+        new(params).execute
+      end
+    end
+
+    def initialize(params)
+      options = params[:options] || {}
+      @commands = 
+        if params[:command]
+          [params[:command]]
+        elsif params[:commands]
+          params[:commands]
+        else
+          []
+        end
+      @success_postback = options.delete(:success)
+      @failure_postback = options.delete(:failure)
+    end
+
+    def execute
+      return self if @commands.empty?
+      if @commands.all? { |command| Job.execute(command).success? }
+        if @success_postback
+          ShellElf.logger.debug("Posting back to #{@success_postback}")
+          Net::HTTP.post_form(URI.parse(@success_postback), {})
+        else
+          ShellElf.logger.debug("No success postback given")
+        end
+      elsif @failure_postback
+        ShellElf.logger.debug("Posting back to #{@failure_postback}")
+        Net::HTTP.post_form(URI.parse(@failure_postback), {})
+      else
+        ShellElf.logger.debug("No failure postback given")
+      end
+      self
+    end
+  end
+end

data/lib/shell_elf/job.rb

@@ -0,0 +1,32 @@
+module ShellElf
+  class Job
+    class <<self
+      def execute(command)
+        new(command).execute
+      end
+    end
+
+    def initialize(command)
+      @command = command
+    end
+
+    def execute
+      escaped_command = Escape.shell_command(@command)
+      ShellElf.logger.info(escaped_command)
+      fork do
+        # this way we can detach from the shell session
+        # so the child process doesn't receive SIGINTs
+        Process.setsid
+        exec(escaped_command)
+      end
+      Process.wait(-1)
+      @success = $? == 0
+      ShellElf.logger.debug(@success ? 'success' : 'failed')
+      self
+    end
+
+    def success?
+      @success
+    end
+  end
+end

data/lib/shell_elf/runner.rb

@@ -0,0 +1,61 @@
+module ShellElf
+  class Runner
+    class <<self
+      private :new
+
+      def run(options)
+        runner = new(options)
+        signal_handler = proc do
+          ShellElf.logger.info("Received signal - gracefully exiting...")
+          exit if runner.interrupted!
+        end
+        trap('INT', &signal_handler)
+        trap('TERM', &signal_handler)
+        runner.run
+      end
+    end
+
+    def initialize(options)
+      @options = options
+    end
+
+    def run
+      until @interrupted
+        if @current = starling.fetch(@options[:queue])
+          ShellElf.logger.debug("RUNNER: #{@current.inspect}")
+          ShellElf::Batch.execute(@current)
+        else
+          sleep Starling::WAIT_TIME
+        end
+      end
+    end
+
+    def interrupted!
+      # return true unless @current
+      if @current && @current[:options] && @current[:options][:on_interrupt] == :requeue
+        starling.set(@options[:queue], @current)
+        true
+      else
+        @interrupted = true
+        false
+      end
+    end
+
+    private
+
+    def starling(delay = nil)
+      begin
+        sleep(delay) if delay
+        @queue ||= Starling.new("#{@options[:host]}:#{@options[:port]}")
+        @queue.stats
+        @queue
+      rescue MemCache::MemCacheError => e
+        ShellElf.logger.error("Unable to connect to Starling: #{e.message}")
+        @queue = nil
+        delay ||= 0.125
+        delay = delay *= 2 if delay < 1
+        retry
+      end
+    end
+  end
+end

data/lib/shell_elf.rb

@@ -0,0 +1,18 @@
+gem 'escape'
+require 'net/http'
+require 'escape'
+require 'logger'
+
+module ShellElf
+  autoload :Job, File.expand_path(File.join(File.dirname(__FILE__), 'shell_elf', 'job.rb'))
+  autoload :Batch, File.expand_path(File.join(File.dirname(__FILE__), 'shell_elf', 'batch.rb'))
+  autoload :Runner, File.expand_path(File.join(File.dirname(__FILE__), 'shell_elf', 'runner.rb'))
+  
+  class <<self
+    attr_writer :logger
+
+    def logger
+      @logger ||= Logger.new(nil) # stub logger
+    end
+  end
+end

data/script/shell-elf-listener

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+gem 'starling-starling'
+gem 'choice'
+require 'starling'
+require 'choice'
+require File.join(File.dirname(File.dirname(__FILE__)), 'lib', 'shell_elf')
+
+Choice.options do 
+  option :queue do
+    short '-q'
+    long '--queue=QUEUE'
+    desc 'Name of starling queue to process'
+    default 'shell_elf'
+  end
+
+  option :host do
+    short '-h'
+    long '--host=HOST'
+    desc 'Host at which to connect to Starling'
+    default '127.0.0.1'
+  end
+
+  option :port do
+    short '-p'
+    long '--port=PORT'
+    desc 'Port on which to connect to Starling'
+    default '22122'
+  end
+
+  option :log_file do
+    long '--log-file=LOG_FILE'
+    desc 'File for logging output'
+  end
+
+  option :log_level do
+    long '--log-level=LOG_LEVEL'
+    desc 'Log level'
+    valid Logger::SEV_LABEL
+    default 'WARN'
+  end
+end
+
+ShellElf.logger = Logger.new(Choice.choices[:log_file])
+ShellElf.logger.progname = "shell_elf[#{Choice.choices[:queue]}]"
+ShellElf.logger.level = Logger.const_get(Choice.choices[:log_level])
+
+ShellElf.logger.info("Starting ShellElf...")
+ShellElf::Runner.run(Choice.choices)
+ShellElf.logger.info("Exiting...")

data/spec/services/http_service.rb

@@ -0,0 +1,9 @@
+require 'rubygems'
+gem 'sinatra'
+require 'fileutils'
+require 'tmpdir'
+require 'sinatra'
+
+post '/touch/:filename' do
+  FileUtils.touch(File.join(Dir.tmpdir, 'shell_elf', 'sandbox', params[:filename]))
+end

data/spec/shell_elf_spec.rb

@@ -0,0 +1,139 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe 'ShellElf' do
+  include SpecHelper
+
+  shared_examples_for 'successful batch' do
+    it 'should postback to success URL' do
+      File.exist?(sandbox('success')).should be_true
+    end
+
+    it 'should not postback to failure URL' do
+      File.exist?(sandbox('failure')).should be_false
+    end
+  end
+
+  shared_examples_for 'failed batch' do
+    it 'should postback to failure URL' do
+      File.exist?(sandbox('failure')).should be_true
+    end
+
+    it 'should not postback to success URL' do
+      File.exist?(sandbox('success')).should be_false
+    end
+  end
+
+  it 'should run a single command' do
+    starling_send_and_wait(:command => ['touch', sandbox('test')])
+    File.exist?(sandbox('test')).should be_true
+  end
+
+  it 'should run multiple commands' do
+    starling_send_and_wait(:commands => [['touch', sandbox('first')], ['touch', sandbox('second')]])
+    %w(first second).all? { |f| File.exist?(sandbox(f)) }.should be_true
+  end
+
+  describe 'on success with single command' do
+    before :each do
+      starling_send_and_wait(:command => ['true'], :options => { :success => http_touch_url('success'), :failure => http_touch_url('failure') })
+    end
+
+    it_should_behave_like 'successful batch'
+  end
+
+  describe 'on failure with single command' do
+    before :each do
+      starling_send_and_wait(:command => ['false'], :options => { :success => http_touch_url('success'), :failure => http_touch_url('failure') })
+    end
+
+    it_should_behave_like 'failed batch'
+  end
+
+  describe 'with failed command followed by successful command' do
+    before :each do
+      starling_send_and_wait(:commands => [['false'], ['touch', sandbox('never_get_here')]], :options => { :success => http_touch_url('success'), :failure => http_touch_url('failure') })
+    end
+
+    it_should_behave_like 'failed batch'
+
+    it 'should not run successful command' do
+      File.exist?(sandbox('never_get_here')).should be_false
+    end
+  end
+
+  describe 'with successful command followed by failed command' do
+    before :each do
+      starling_send_and_wait(:commands => [['touch', sandbox('first')], ['false']], :options => { :success => http_touch_url('success'), :failure => http_touch_url('failure') })
+    end
+
+    it_should_behave_like 'failed batch'
+
+    it 'should run successful command' do
+      File.exist?(sandbox('first')).should be_true
+    end
+  end
+
+  describe 'with bogus input' do
+    before :each do
+      starling_send('bogus')
+      starling_send_and_wait(:command => ['touch', sandbox('success')])
+    end
+
+    it 'should continue running' do
+      File.exist?(sandbox('success')).should be_true
+    end
+  end
+
+  describe 'with empty commands' do
+    before :each do
+      starling_send(:commands => [], :success => http_touch_url('success'), :failure => http_touch_url('failure'))
+      starling_send_and_wait(:command => ['touch', sandbox('after')])
+    end
+
+    %w(success failure).each do |postback|
+      it "should not send #{postback} postback" do
+        File.exist?(sandbox(postback)).should be_false
+      end
+    end
+
+    it 'should continue running' do
+      File.exist?(sandbox('after')).should be_true
+    end
+  end
+
+  %w(TERM INT).each do |signal|
+    describe "when SIG#{signal} sent" do 
+      before :each do
+        starling_wait
+        starling_send(:commands => [['kill', '-s', signal, shell_elf_pid.to_s], ['touch', sandbox('done')]])
+        starling_send(:command => ['touch', sandbox('never_get_here')])
+        wait_for_exit
+      end
+
+      it 'should trap the signal and complete current command before exiting' do
+        File.exist?(sandbox('done')).should be_true
+      end
+
+      it 'should not run any further commands' do
+        File.exist?(sandbox('never_get_here')).should be_false
+      end
+    end
+
+    describe "when SIG#{signal} sent with requeue option" do
+      before :each do
+        @params = { :commands => [['kill', '-s', signal, shell_elf_pid.to_s], ['touch', sandbox('requeued')]], :options => { :on_interrupt => :requeue }}
+        starling_wait
+        starling_send(@params)
+        wait_for_exit
+      end
+
+      it 'should trap the signal and requeue the job' do
+        @starling.fetch('shell_elf_test').should == @params
+      end
+
+      it 'should not finish the running command' do
+        File.exist?(sandbox('requeued')).should be_false
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,77 @@
+require 'rubygems'
+gem 'rspec'
+gem 'starling-starling'
+require 'fileutils'
+require 'tmpdir'
+require 'spec'
+require 'starling'
+require 'ruby-debug'
+
+Spec::Runner.configure do |config|
+  config.before(:all) do
+    @starling = Starling.new('localhost:73787')
+    begin
+      @starling.stats
+    rescue
+      abort('Starling is not responding! Run rake spec:environment to start background services.')
+    end
+  end
+
+  config.before(:each) do
+    @starling.delete('shell_elf_test')
+    for entry in Dir.glob(File.join(Dir.tmpdir, 'shell_elf', 'sandbox', '*'))
+      if File.file?(entry)
+        FileUtils.rm_r(File.expand_path(entry))
+      end
+    end
+  end
+
+  config.after(:each) do
+    @starling.delete('shell_elf_test')
+  end
+end
+
+module SpecHelper
+  def sandbox(*path)
+    File.expand_path(File.join(Dir.tmpdir, 'shell_elf', 'sandbox', path))
+  end
+
+  def starling_send_and_wait(params)
+    starling_send(params)
+    starling_wait
+  end
+
+  def starling_send(params)
+    @starling.set('shell_elf_test', params)
+  end
+
+  def starling_wait
+    starling_send(:command => ['true'])
+    100.times do |i|
+      return if @starling.sizeof('shell_elf_test') == 0
+      sleep 0.01
+    end
+    raise 'Timed out waiting for Starling queue to clear.'
+  end
+
+  def http_touch_url(filename)
+    "http://localhost:7397/touch/#{filename}"
+  end
+
+  def wait_for_exit(timeout = 1)
+    pid = shell_elf_pid
+    (timeout * 100).times do
+      begin
+        Process.kill(0, pid)
+        sleep 0.01
+      rescue Errno::ESRCH
+        return
+      end
+    end
+    raise "Timed out waiting for pid #{pid} to end!"
+  end
+
+  def shell_elf_pid
+    File.open(File.join(Dir.tmpdir, 'shell_elf', 'log', 'shell-elf.pid')) { |f| f.read.to_i }
+  end
+end

data/tasks/gemspec.rake

@@ -0,0 +1,22 @@
+begin
+  gem 'technicalpickles-jeweler', '~> 0.8.1'
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = 'shell_elf'
+    s.executables = 'shell-elf'
+    s.summary = 'Daemon which executes shell commands read out of a Starling queue and optionally posts back to an HTTP server on success/failure'
+    s.email = 'mat@patch.com'
+    s.homepage = 'http://github.com/outoftime/sunspot'
+    s.description = 'Daemon which executes shell commands read out of a Starling queue and optionally posts back to an HTTP server on success/failure'
+    s.authors = ['Mat Brown']
+    s.files = FileList['[A-Z]*', '{bin,lib,spec,tasks,script}/**/*']
+    s.has_rdoc = false
+    s.add_dependency 'escape', '>= 0.0.4'
+    s.add_dependency 'starling-starling', '~> 0.9'
+    s.add_dependency 'daemons', '~> 1.0'
+    s.add_dependency 'choice', '>= 0.1'
+    s.add_development_dependency 'rspec', '~> 1.1'
+    s.add_development_dependency 'ruby-debug', '~> 0.10'
+    s.add_development_dependency 'sinatra', '>= 0.9'
+  end
+end

data/tasks/spec.rake

@@ -0,0 +1,36 @@
+require 'fileutils'
+require 'tmpdir'
+require 'spec/rake/spectask'
+
+desc 'Run spec suite'
+Spec::Rake::SpecTask.new('spec') do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+namespace :spec do
+  desc "Start spec environment processes"
+  task :environment do
+    base_dir = File.expand_path(File.dirname(File.dirname(__FILE__)))
+    spec_dir = File.join(base_dir, 'spec')
+    tmp_dir = File.join(Dir.tmpdir, 'shell_elf')
+    FileUtils.mkdir_p(File.join(tmp_dir, 'log'))
+    FileUtils.mkdir_p(File.join(tmp_dir, 'sandbox'))
+    running = true
+    trap('INT') { running = false }
+    trap('TERM') { running = false }
+    fork do
+      exec("starling -P #{File.join(tmp_dir, 'log', 'starling.pid')} -p 73787")
+    end
+    fork do
+      exec("ruby #{spec_dir}/services/http_service.rb -p 7397")
+    end
+    while running
+      shell_elf_pid = fork do
+        exec("#{File.join(base_dir, 'bin', 'shell-elf')} run -- -p 73787 -q shell_elf_test --log-file=#{File.join(tmp_dir, 'log', 'shell_elf.out')} --log-level=DEBUG")
+      end
+      File.open(File.join(tmp_dir, 'log', 'shell-elf.pid'), 'w') { |f| f << shell_elf_pid }
+      Process.waitpid(shell_elf_pid)
+    end
+    Process.waitall
+  end
+end

metadata

@@ -0,0 +1,138 @@
+--- !ruby/object:Gem::Specification 
+name: outoftime-shell_elf
+version: !ruby/object:Gem::Version 
+  version: 0.9.0
+platform: ruby
+authors: 
+- Mat Brown
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-04-01 00:00:00 -07:00
+default_executable: shell-elf
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: escape
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.0.4
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: starling-starling
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "0.9"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: daemons
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "1.0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: choice
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0.1"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "1.1"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: ruby-debug
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "0.10"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: sinatra
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0.9"
+    version: 
+description: Daemon which executes shell commands read out of a Starling queue and optionally posts back to an HTTP server on success/failure
+email: mat@patch.com
+executables: 
+- shell-elf
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- README.rdoc
+- VERSION.yml
+- bin/shell-elf
+- lib/shell_elf
+- lib/shell_elf/runner.rb
+- lib/shell_elf/batch.rb
+- lib/shell_elf/job.rb
+- lib/shell_elf.rb
+- spec/spec_helper.rb
+- spec/services
+- spec/services/http_service.rb
+- spec/shell_elf_spec.rb
+- tasks/gemspec.rake
+- tasks/spec.rake
+- script/shell-elf-listener
+has_rdoc: true
+homepage: http://github.com/outoftime/sunspot
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Daemon which executes shell commands read out of a Starling queue and optionally posts back to an HTTP server on success/failure
+test_files: []
+