ittayd-buildr 1.3.4

data/addon/buildr/jetty.rb

@@ -0,0 +1,248 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with this
+# work for additional information regarding copyright ownership.  The ASF
+# licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+
+require 'uri'
+require 'net/http'
+require 'buildr/core/project'
+require 'buildr/java'
+require 'buildr/packaging'
+require 'thread'
+
+
+module Buildr
+
+  # Provides a collection of tasks and methods for using Jetty, specifically as a server
+  # for testing your application.
+  #
+  # Build files should always start Jetty by invoking the #use task, typically as
+  # a prerequisite. This task will start Jetty once during the build, and shut it down
+  # when the build completes.
+  #
+  # If you want to keep Jetty running across builds, and look at error messages, you can
+  # start Jetty in a separate console with:
+  #   buildr jetty:start
+  # To stop this instance of Jetty, simply kill the process (Ctrl-C) or run:
+  #   buildr jetty:stop
+  #
+  # If you start Jetty separately from the build, the #use task will connect to that
+  # existing server. Since you are using Jetty across several builds, you will want to
+  # cleanup any mess created by each build. You can use the #setup and #teardown tasks,
+  # which are called when Jetty is first used in the build, and when the build ends.
+  class Jetty
+
+    # Which version of Jetty we're using by default (change with options.jetty.version).
+    VERSION = "6.1.3"
+    SLF4J_VERSION = "1.4.3"
+    
+    # Libraries used by Jetty.
+    REQUIRES = [ "org.mortbay.jetty:jetty:jar:#{VERSION}", "org.mortbay.jetty:jetty-util:jar:#{VERSION}",
+      "org.mortbay.jetty:servlet-api-2.5:jar:#{VERSION}", "org.slf4j:slf4j-api:jar:#{SLF4J_VERSION}", 
+      "org.slf4j:slf4j-simple:jar:#{SLF4J_VERSION}", "org.slf4j:jcl104-over-slf4j:jar:#{SLF4J_VERSION}" ]
+     
+    Java.classpath <<  REQUIRES
+    Java.classpath << File.dirname(__FILE__)
+    
+    # Default URL for Jetty (change with options.jetty.url).
+    URL = "http://localhost:8080"
+
+    class << self
+
+      # :call-seq:
+      #   instance() => Jetty
+      #
+      # Returns an instance of Jetty.
+      def instance()
+        @instance ||= Jetty.new("jetty", URL)
+      end
+
+    end
+
+    def initialize(name, url) #:nodoc:
+      @url = url
+      namespace name do
+        @setup = task("setup")
+        @teardown = task("teardown")
+        @use = task("use") { fire }
+      end
+    end
+
+    # The URL for the Jetty server. Leave as is if you want to use the default server
+    # (http://localhost:8080).
+    attr_accessor :url
+
+    # :call-seq:
+    #    start(pipe?)
+    #
+    # Starts Jetty. This method does not return, it keeps the thread running until
+    # Jetty is stopped. If you want to run Jetty parallel with other tasks in the build,
+    # invoke the #use task instead.
+    def start(sync = nil)
+      begin
+        puts "classpath #{Java.classpath.inspect}"
+        port = URI.parse(url).port
+        puts "Starting Jetty at http://localhost:#{port}" if verbose
+        Java.load
+        jetty = Java.org.apache.buildr.JettyWrapper.new(port)
+        sync << "Started" if sync
+        sleep # Forever
+      rescue Interrupt # Stopped from console
+      rescue Exception=>error
+        puts "#{error.class}: #{error.message}"
+      end
+      exit! # No at_exit
+    end
+
+    # :call-seq:
+    #    stop()
+    #
+    # Stops Jetty. Stops a server running in a separate process.
+    def stop()
+      uri = URI.parse(url)
+      begin
+        Net::HTTP.start(uri.host, uri.port) do |http|
+          http.request_post "/buildr/stop", ""
+        end
+      rescue Errno::ECONNREFUSED
+        # Expected if Jetty server not running.
+      rescue EOFError
+        # We get EOFError because Jetty is brutally killed.
+      end
+      puts "Jetty server stopped"
+    end
+
+    # :call-seq:
+    #   running?() => boolean
+    #
+    # Returns true if it finds a running Jetty server that supports the Buildr
+    # requests for deploying, stopping, etc.
+    def running?()
+      uri = URI.parse(url)
+      begin
+        Net::HTTP.start(uri.host, uri.port) do |http|
+          response = http.request_get("/buildr/")
+          response.is_a?(Net::HTTPSuccess) && response.body =~ /Alive/
+        end
+      rescue Errno::ECONNREFUSED, Errno::EBADF 
+        false
+      end
+    end
+
+    # :call-seq:
+    #   deploy(url, webapp) => path
+    #
+    # Deploy a WAR in the specified URL.
+    def deploy(url, webapp)
+      use.invoke
+      uri = URI.parse(url)
+      Net::HTTP.start(uri.host, uri.port) do |http|
+        response = http.request_post("/buildr/deploy", "webapp=#{webapp}&path=#{uri.path}")
+        if Net::HTTPOK === response && response.body =~ /Deployed/
+          path = response.body.split[1]
+          puts "Deployed #{webapp}, context path #{uri.path}" if Rake.application.options.trace
+          path
+        else
+          fail "Deployment failed: #{response}"
+        end
+      end
+    end
+
+    # :call-seq:
+    #   undeploy(url) => boolean
+    #
+    # Undeploys a WAR from the specified URL.
+    def undeploy(url)
+      use.invoke
+      uri = URI.parse(url)
+      Net::HTTP.start(uri.host, uri.port) do |http|
+        response = http.request_post("/buildr/undeploy", "path=#{uri.path}")
+        if Net::HTTPOK === response && response.body =~ /Undeployed/
+          true
+        else
+          fail "Deployment failed: #{response}"
+        end
+      end
+    end
+
+    # :call-seq:
+    #   setup(*prereqs) => task
+    #   setup(*prereqs) { |task| .. } => task
+    #
+    # This task executes when Jetty is first used in the build. You can use it to
+    # deploy artifacts into Jetty.
+    def setup(*prereqs, &block)
+      @setup.enhance prereqs, &block
+    end
+
+    # :call-seq:
+    #   teardown(*prereqs) => task
+    #   teardown(*prereqs) { |task| .. } => task
+    #
+    # This task executes when the build is done. You can use it to undeploy artifacts
+    # previously deployed into Jetty.
+    def teardown(*prereqs, &block)
+      @teardown.enhance prereqs, &block
+    end
+
+    # :call-seq:
+    #   use(*prereqs) => task
+    #   use(*prereqs) { |task| .. } => task
+    #
+    # If you intend to use Jetty, invoke this task. It will start a new instance of
+    # Jetty and close it when the build is done. However, if you already have a server
+    # running in the background (e.g. jetty:start), it will use that server and will
+    # not close it down.
+    def use(*prereqs, &block)
+      @use.enhance prereqs, &block
+    end
+
+  protected
+
+    # If you want to start Jetty inside the build, call this method instead of #start.
+    # It will spawn a separate process that will run Jetty, and will stop Jetty when
+    # the build ends. However, if you already started Jetty from the console (with
+    # take jetty:start), it will use the existing instance without shutting it down.
+    def fire()
+      unless running?
+        sync = Queue.new
+        Thread.new { start sync }
+        # Wait for Jetty to fire up before doing anything else.
+        sync.pop == "Started" or fail "Jetty not started"
+        puts "Jetty started" if verbose
+        at_exit { stop }
+      end
+      @setup.invoke
+      at_exit { @teardown.invoke }
+    end
+
+  end
+
+  namespace "jetty" do
+    desc "Start an instance of Jetty running in the background"
+    task("start") { Jetty.instance.start }
+    desc "Stop an instance of Jetty running in the background"
+    task("stop") { Jetty.instance.stop }
+  end
+
+  # :call-seq:
+  #   jetty() => Jetty
+  #
+  # Returns a Jetty object. You can use this to discover the Jetty#use task,
+  # configure the Jetty#setup and Jetty#teardown tasks, deploy and undeploy to Jetty.
+  def jetty()
+    @jetty ||= Jetty.instance
+  end
+
+end

data/addon/buildr/jibx.rb

@@ -0,0 +1,86 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with this
+# work for additional information regarding copyright ownership.  The ASF
+# licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+
+require 'java/java'
+
+
+module Buildr
+
+  # Provides JiBX bytecode enhancement. Require explicitly using <code>require 'buildr/jibx'</code>.
+  module JiBX 
+
+    JIBX_VERSION = '1.1.5'
+    BCEL_VERSION = '5.2'
+    STAX_VERSION = '1.0-2'
+    XPP3_VERSION = '1.1.4c'
+
+    REQUIRES = [ "org.jibx:jibx-bind:jar:#{JIBX_VERSION}",
+      "org.jibx:jibx-run:jar:#{JIBX_VERSION}",
+      "org.apache.bcel:bcel:jar:#{BCEL_VERSION}",
+      "javax.xml.stream:stax-api:jar:#{STAX_VERSION}",
+      "xpp3:xpp3:jar:#{XPP3_VERSION}" ]
+
+    Java.classpath << REQUIRES
+
+    class << self
+
+      def bind(options)
+        rake_check_options options, :classpath, :output, :binding, :target, :verbose, :load
+        artifacts = Buildr.artifacts(options[:classpath]).each { |a| a.invoke }.map(&:to_s) + [options[:output].to_s]
+        binding = file(options[:binding]).tap { |task| task.invoke }.to_s
+
+        Buildr.ant 'jibx' do |ant|
+          ant.taskdef :name=>'bind', :classname=>'org.jibx.binding.ant.CompileTask',
+            :classpath => requires.join(File::PATH_SEPARATOR)
+          ant.bind :verbose => options[:verbose].to_s, :load => options[:load].to_s, :binding=>options[:binding].to_s do
+            ant.classpath :path => artifacts.join(File::PATH_SEPARATOR)
+          end
+        end
+      end
+
+    private
+
+      def requires()
+        @requires ||= Buildr.artifacts(REQUIRES).each { |artifact| artifact.invoke }.map(&:to_s)
+      end
+
+    end
+
+    def jibx_bind(options = nil)
+      
+      # FIXME - add support for :bindingfileset and :classpathset
+      # Note: either :binding or :bindingfileset should be set, and either
+      # :classpath or :classpathset should be set, and options passed to
+      # ant.bind should be adjusted accordingly. At present, only :binding
+      # and :classpath are supported (which should be fine for most!)
+      jibx_options = { :output => compile.target,
+        :classpath => compile.classpath,
+        :binding => path_to(:source, :main, :resources, 'META-INF/binding.xml'),
+        :target => compile.target,
+        :load => false,
+        :verbose => false
+      }
+
+      JiBX.bind jibx_options.merge(options || {})
+    end
+
+  end
+
+  class Project
+    include JiBX 
+  end
+end
+

data/addon/buildr/nailgun.rb

@@ -0,0 +1,221 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with this
+# work for additional information regarding copyright ownership.  The ASF
+# licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+
+require 'jruby'
+require 'rbconfig'
+require 'tmpdir'
+require 'buildr/drb'
+
+
+module Buildr
+  
+  # This addon is provided for fast interaction with a DRb BuildrServer (buildr/drb).
+  # 
+  # This module delegates task invocation to the BuildrServer, it only implements
+  # nailgun required logic (server/client).
+  #
+  # Usage:
+  #
+  #   buildr -r buildr/nailgun nailgun:start
+  # 
+  # Once the server has been started you can invoke tasks using the nailgun client
+  # installed on $JRUBY_HOME/tool/nailgun. It's recommended to add this path to 
+  # your PATH environment variable, so that the ng command is available at any dir.
+  #
+  #   ng build # invoke the build task
+  #
+  module Nailgun
+    extend self
+
+    VERSION = '0.7.1'
+    NAME = "nailgun-#{VERSION}"
+    URL = "http://downloads.sourceforge.net/nailgun/#{NAME}.zip"
+    ARTIFACT_SPEC = "com.martiansoftware:nailgun:jar:#{VERSION}"
+    PORT = DRbApplication::PORT + 2
+    ADDON_BIN = File.dirname(__FILE__)
+    
+    # Returns the path to JRUBY_HOME.
+    def jruby_home
+      ENV['JRUBY_HOME'] || Config::CONFIG['prefix']
+    end
+    
+    # Returns the path to NAILGUN_HOME.
+    def nailgun_home
+      ENV['NAILGUN_HOME'] || File.expand_path('tool/nailgun', jruby_home)
+    end
+
+    def tmp_path(*paths)
+      File.join(Dir.tmpdir, 'nailgun', *paths)
+    end
+
+    module Util
+      extend self
+
+      def add_to_sysloader(path)
+        sysloader = java.lang.ClassLoader.getSystemClassLoader
+        add_url_method = java.lang.Class.forName('java.net.URLClassLoader').
+          getDeclaredMethod('addURL', [java.net.URL.java_class].to_java(java.lang.Class))
+        add_url_method.setAccessible(true)
+        add_url_method.invoke(sysloader, [java.io.File.new(path).toURI.toURL].to_java(java.net.URL))
+      end
+
+      # invoke a java constructor
+      def ctor(on_class, *args)
+        parameters = []
+        classes = []
+        args.each do |obj|
+          case obj
+          when nil
+            classes.push(nil)
+            parameters.push(nil)
+          when Hash
+            vclass = obj.keys.first
+            value = obj[vclass]
+            classes.push(vclass.java_class)
+            parameters.push(value)
+          else
+            parameters.push obj
+            classes.push obj.class.java_class
+          end
+        end
+        on_class = [on_class.java_class].to_java(java.lang.Class)[0]
+        ctor = on_class.getDeclaredConstructor(classes.to_java(java.lang.Class))
+        ctor.setAccessible(true)
+        ctor.newInstance(parameters.to_java(java.lang.Object))
+      end
+
+    end # Util
+
+    module Client
+
+      def main(nail)
+        nail.out.println "Connected to #{nail.getNGServer}"
+
+        runtime = JRuby.runtime
+
+        stdout = Util.ctor(org.jruby.RubyIO, runtime, java.io.OutputStream => nail.out)
+        stderr = Util.ctor(org.jruby.RubyIO, runtime, java.io.OutputStream => nail.err)
+        stdin = Util.ctor(org.jruby.RubyIO, runtime, java.io.InputStream => nail.in)
+        
+        dir = nail.getWorkingDirectory
+        argv = [nail.command] + nail.args
+        
+        DRbApplication.remote_run :dir => dir, :argv => argv,
+                                  :in => stdin, :out => stdout, :err => stderr
+      rescue => e
+        nail.err.println e unless SystemExit === e
+        nail.exit 1
+      end
+      
+    end # Client
+
+    module Server
+      def initialize(host, port)
+        @host = host || "*"
+        @port = port
+        super(host, port)
+      end
+
+      def start
+        self.allow_nails_by_class_name = false
+        
+        NGClient::Main.nail = NGClient.new
+        self.default_nail_class = NGClient::Main
+        
+        @thread = java.lang.Thread.new(self)
+        @thread.setName(to_s)
+        @thread.start
+        
+        sleep 1 while getPort == 0
+        info "#{self} Started."
+      end
+      
+      def stop
+        @thread.kill
+      end
+
+      def to_s
+        version = "Buildr #{Buildr::VERSION} #{RUBY_PLATFORM[/java/] && '(JRuby '+JRUBY_VERSION+')'}"
+        self.class.name+'('+[version, @host, @port].join(', ')+')'
+      end
+    end # Server
+
+    namespace(:nailgun) do
+
+      dist_zip = Buildr.download(tmp_path(NAME + '.zip') => URL)
+      dist_dir = Buildr.unzip(tmp_path(NAME) => dist_zip)
+      
+      nailgun_jar = file(tmp_path(NAME, NAME, NAME + '.jar'))
+      nailgun_jar.enhance [dist_dir] unless File.exist?(nailgun_jar.to_s)
+
+      attr_reader :artifact
+      @artifact = Buildr.artifact(ARTIFACT_SPEC).from(nailgun_jar)
+      
+      compiled_bin = file(tmp_path(NAME, NAME, 'ng' + Config::CONFIG['EXEEXT']) => dist_dir.target) do |task|
+        unless task.to_s.pathmap('%x') == '.exe'
+          Dir.chdir(task.to_s.pathmap('%d')) do
+            info "Compiling #{task.to_s}"
+            system('make', task.to_s.pathmap('%f')) or
+              fail "Nailgun binary compilation failed."
+          end
+        end
+      end
+
+      attr_reader :installed_bin
+      @installed_bin = file(File.expand_path(compiled_bin.to_s.pathmap('%f'), nailgun_home) => compiled_bin) do |task|
+        mkpath task.to_s.pathmap('%d'), :verbose => false
+        cp compiled_bin.to_s, task.to_s, :verbose => false
+      end
+
+      task('drb-notice') do
+        info ''
+        info 'Running in JRuby, a nailgun server will be started so that'
+        info 'you can use your nailgun client to invoke buildr tasks: '
+        info ''
+        info '  '+Nailgun.installed_bin.to_s
+        info ''
+      end
+
+      task('drb' => ['drb-notice', 'start'])
+
+      desc 'Start the nailgun server'
+      task('start' => [installed_bin, 'setup']) do |task|
+        server = NGServer.new(nil, PORT)
+        server.start
+      end
+
+      task('setup' => artifact) do 
+        module Util
+          include Buildr::Util
+        end
+        
+        Util.add_to_sysloader artifact.to_s
+        Util.add_to_sysloader ADDON_BIN
+        
+        class NGClient
+          include org.apache.buildr.BuildrNail
+          include Client
+        end
+        
+        class NGServer < com.martiansoftware.nailgun.NGServer
+          include Server
+        end      
+      end
+      
+    end # ng_tasks
+      
+  end # module Nailgun
+end

data/addon/buildr/openjpa.rb

@@ -0,0 +1,90 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with this
+# work for additional information regarding copyright ownership.  The ASF
+# licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+
+require 'buildr/java'
+
+
+module Buildr
+
+  # Provides OpenJPA bytecode enhancement and Mapping tool task. Require explicitly using <code>require "buildr/openjpa"</code>.
+  module OpenJPA
+
+    VERSION = "1.0.1"
+
+    REQUIRES = [ "org.apache.openjpa:openjpa:jar:#{VERSION}",
+      "commons-collections:commons-collections:jar:3.1",
+      "commons-dbcp:commons-dbcp:jar:1.2.1", 
+      "commons-lang:commons-lang:jar:2.1",
+      "commons-pool:commons-pool:jar:1.2",
+      "javax.persistence:persistence-api:jar:1.0",
+      "org.apache.geronimo.specs:geronimo-j2ee-connector_1.5_spec:jar:1.0",
+      "org.apache.geronimo.specs:geronimo-jta_1.0.1B_spec:jar:1.0",
+      "net.sourceforge.serp:serp:jar:1.11.0" ]
+
+    Java.classpath << REQUIRES
+
+    class << self
+
+      def enhance(options)
+        rake_check_options options, :classpath, :properties, :output
+        artifacts = Buildr.artifacts(options[:classpath]).each { |a| a.invoke }.map(&:to_s) + [options[:output].to_s]
+        properties = file(options[:properties]).tap { |task| task.invoke }.to_s
+
+        Buildr.ant "openjpa" do |ant|
+          ant.taskdef :name=>"enhancer", :classname=>"org.apache.openjpa.ant.PCEnhancerTask",
+            :classpath=>requires.join(File::PATH_SEPARATOR)
+          ant.enhancer :directory=>options[:output].to_s do
+            ant.config :propertiesFile=>properties
+            ant.classpath :path=>artifacts.join(File::PATH_SEPARATOR)
+          end
+        end
+      end
+
+      def mapping_tool(options)
+        rake_check_options options, :classpath, :properties, :sql, :action
+        artifacts = Buildr.artifacts(options[:classpath]).each{ |a| a.invoke }.map(&:to_s)
+        properties = file(options[:properties].to_s).tap { |task| task.invoke }.to_s
+
+        Buildr.ant("openjpa") do |ant|
+          ant.taskdef :name=>"mapping", :classname=>"org.apache.openjpa.jdbc.ant.MappingToolTask",
+            :classpath=>requires.join(File::PATH_SEPARATOR)
+          ant.mapping :schemaAction=>options[:action], :sqlFile=>options[:sql].to_s, :ignoreErrors=>"true" do
+            ant.config :propertiesFile=>properties
+            ant.classpath :path=>artifacts.join(File::PATH_SEPARATOR)
+          end
+        end
+      end
+
+    private
+
+      def requires()
+        @requires ||= Buildr.artifacts(REQUIRES).each { |artifact| artifact.invoke }.map(&:to_s)
+      end
+
+    end
+
+    def open_jpa_enhance(options = nil)
+      jpa_options = { :output=>compile.target, :classpath=>compile.dependencies,
+                      :properties=>path_to(:source, :main, :resources, 'META-INF/persistence.xml') }
+      OpenJPA.enhance jpa_options.merge(options || {})
+    end
+
+  end
+
+  class Project
+    include OpenJPA
+  end
+end

data/addon/buildr/org/apache/buildr/BuildrNail.java

@@ -0,0 +1,41 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with this
+ * work for additional information regarding copyright ownership.  The ASF
+ * licenses this file to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ */
+
+
+package org.apache.buildr;
+
+import com.martiansoftware.nailgun.NGContext;
+
+public interface BuildrNail {
+  
+  public void main(NGContext ctx);
+
+  public static class Main {
+     private static BuildrNail nail;
+     public static void  setNail(BuildrNail _nail) { nail = _nail; }
+     public static void nailMain(NGContext ctx) {
+       nail.main(ctx);
+     }
+  }
+
+}
+
+/* 
+ * Local Variables:
+ * indent-tabs-mode: nil
+ * c-basic-offset: 2
+ * End:
+ */