jenkins-plugin-runtime 0.1.6 → 0.1.7

data/lib/jenkins/filepath.rb

@@ -0,0 +1,133 @@
+require 'pathname'
+
+module Jenkins
+  class FilePath
+    Stat = Struct.new(:size, :mode, :mtime)
+
+    attr_reader :natvie
+
+    def initialize(native)
+      @native = native
+    end
+
+    # Ruby's Pathname internace
+
+    def +(name)
+      FilePath.new(@native.child(name))
+    end
+
+    def to_s
+      @native.getRemote()
+    end
+
+    def realpath
+      @native.absolutize().getRemote()
+    end
+
+    def read(*args)
+      @native.read.to_io.read(*args)
+    end
+
+    # TODO: atime jnr-posix?
+    # TODO: ctime jnr-posix?
+
+    def mtime
+      Time.at(@native.lastModified().to_f / 1000)
+    end
+
+    def chmod(mask)
+      @native.chmod(mask)
+    end
+
+    # TODO: chown
+    # TODO: open
+
+    def rename(to)
+      @native.renameTo(create_filepath(to))
+    end
+
+    def stat
+      Stat.new(size, @native.mode(), mtime)
+    end
+
+    # TODO: utime
+
+    def basename
+      FilePath.new(create_filepath(@native.getName()))
+    end
+
+    # TODO: dirname
+    # TODO: extname
+
+    def exist?
+      @native.exists()
+    end
+
+    def directory?
+      @native.isDirectory()
+    end
+
+    def file?
+      !directory?
+    end
+
+    def size
+      @native.length()
+    end
+
+    def entries
+      @native.list().map { |native|
+        FilePath.new(native)
+      }
+    end
+
+    def mkdir
+      @native.mkdirs
+    end
+
+    # TODO: rmdir
+    # TODO: opendir
+
+    def each_entry(&block)
+      entries.each do |child|
+        yield child
+      end
+    end
+
+    def delete
+      @native.delete()
+    end
+    alias unlink delete
+
+    def rmtree
+      @native.deleteRecursive()
+    end
+
+    # TODO: hudson.FilePath does not handle FilePath(".").parent since it scans
+    # the last "/" for file, the 2nd last "/" for directory. Can Jenkins handle
+    # new FilePatn(ch, "../..") correctly?
+    def parent
+      parent = Pathname.new(to_s).parent.to_s
+      FilePath.new(Java.hudson.FilePath.new(@native.getChannel(), parent))
+    end
+
+    # Original interface
+
+    def touch(time)
+      @native.touch(time.to_i * 1000)
+    end
+
+    def remote?
+      @native.isRemote()
+    end
+
+    # TODO: createTempDir
+    # TODO: createTempFile
+
+  private
+
+    def create_filepath(path)
+      Java.hudson.FilePath.new(@native.getChannel(), path)
+    end
+  end
+end

data/lib/jenkins/launcher.rb

@@ -1,8 +1,40 @@
-
 module Jenkins
 
   # Launch processes on build slaves. No functionality is currently exposed
   class Launcher
+    class Proc
+      attr_reader :natvie
+
+      def initialize(native)
+        @native = native
+      end
+
+      def alive?
+        @native.isAlive()
+      end
+
+      def join
+        @native.join()
+      end
+
+      def kill
+        @native.kill()
+        nil
+      end
+
+      def stdin
+        @native.getStdin().to_io
+      end
+
+      def stdout
+        @native.getStdout().to_io
+      end
+
+      def stderr
+        @native.getStderr().to_io
+      end
+    end
+
     # the native hudson.Launcher object
     attr_reader :native
 
@@ -10,11 +42,76 @@ module Jenkins
       @native = native
     end
 
-    # TODO: wrap needed.
-    # Do we really wrap whole Launcher.ProcStarter things?
-    # Or create our own Launcher (must support remote, local, etc)
-    def launch
-      @native.launch()
+    # execute([env,] command... [,options]) -> fixnum
+    def execute(*args)
+      spawn(*args).join
+    end
+
+    # spawn([env,] command... [,options]) -> proc
+    def spawn(*args)
+      env, cmd, options = scan_args(args)
+
+      starter = @native.launch()
+      starter.envs(env)
+      if opt_chdir = options[:chdir]
+        starter.pwd(opt_chdir.to_s)
+      end
+      if opt_in = options[:in]
+        starter.stdin(opt_in.to_inputstream)
+      end
+      if opt_out = options[:out]
+        if opt_out.is_a?(Jenkins::Model::Listener)
+          starter.stdout(Jenkins::Plugin.instance.export(opt_out))
+        else
+          starter.stdout(opt_out.to_outputstream)
+        end
+      end
+      if opt_err = options[:err]
+        starter.stderr(opt_err.to_outputstream)
+      end
+      case cmd
+      when Array
+        starter.cmds(cmd)
+      else
+        begin
+          # when we are on 1.432, we can use cmdAsSingleString
+          starter.cmdAsSingleString(cmd.to_s)
+        rescue NoMethodError
+          # http://d.hatena.ne.jp/sikakura/20110324/1300977208 is doing
+          # Arrays.asList(str.split(" ")) which should be wrong.
+          require 'shellwords'
+          starter.cmds(*Shellwords.split(cmd.to_s))
+        end
+      end
+      Proc.new(starter.start())
+    end
+
+  private
+
+    def scan_args(args)
+      if args.last
+        if Hash === args.last
+          opt = args.pop
+        elsif args.last.respond_to?(:to_hash)
+          opt = args.pop.to_hash
+        end
+      end
+      if args.first
+        if Hash === args.first
+          env = args.shift
+        elsif args.first.respond_to?(:to_hash)
+          env = args.shift.to_hash
+        end
+        if env
+          env = env.inject({}) { |r, (key, value)| r[key.to_s] = value.to_s; r }
+        end
+      end
+      if args.length == 1
+        cmd = args.first
+      else
+        cmd = args
+      end
+      [env || {}, cmd, opt || {}]
     end
 
     Plugin::Proxies.register self, Java.hudson.Launcher

data/lib/jenkins/model/action.rb

@@ -1,23 +1,14 @@
 
-#TODO: does this make more sense as a class? maybe
+require 'jenkins/model'
 
 module Jenkins
   module Model
-    module Action
-      include Model
 
-      module Included
-        def included(cls)
-          super(cls)
-          if cls.class == Module
-            cls.extend(Included)
-          else
-            cls.extend(ClassMethods)
-            cls.send(:include, InstanceMethods)
-          end
-        end
-      end
-      extend Included
+    # TODO: I turned Action into Class from Module but it should be a bad idea.
+    # The change may be reverted. I used class Action for implementing a model
+    # as a describable but I really should do is implementing describable.
+    class Action
+      include Model
 
       module InstanceMethods
         def icon
@@ -28,7 +19,7 @@ module Jenkins
           self.class.url_path
         end
       end
-      #
+
       module ClassMethods
         def icon(filename = nil)
           filename.nil? ? @icon : @icon = filename.to_s
@@ -38,6 +29,9 @@ module Jenkins
           path.nil? ? @url_path : @url_path = path.to_s
         end
       end
+
+      include InstanceMethods
+      extend ClassMethods
     end
   end
-end
+end

data/lib/jenkins/model/build.rb

@@ -1,3 +1,4 @@
+require 'jenkins/filepath'
 
 module Jenkins
   module Model
@@ -13,16 +14,16 @@ module Jenkins
         @native = native
       end
 
+      def workspace
+        FilePath.new(@native.getWorkspace())
+      end
+
       def build_var
         @native.getBuildVariables()
       end
 
-      def env(listener = nil)
-        if listener
-          # TODO: not tested. dump to listener?
-          listener = Plugin.instance.export(listener)
-        end
-        @native.getEnvironment(listener)
+      def env
+        @native.getEnvironment(nil)
       end
 
       Jenkins::Plugin::Proxies.register self, Java.hudson.model.AbstractBuild

data/lib/jenkins/model/describable.rb

@@ -17,7 +17,7 @@ module Jenkins
     # you can use this ruby class too. e.g.
     #
     #     class Builder
-    #       include Jenkins::Model::Describeable
+    #       include Jenkins::Model::Describable
     #       describe_as Java.hudson.tasks.Builder
     #     end
     #

data/lib/jenkins/model/descriptor.rb

@@ -6,7 +6,7 @@ module Jenkins
     class Descriptor < Java.hudson.model.Descriptor
 
       def initialize(impl, plugin, java_type)
-        super(Java.org.jruby.RubyObject.java_class)
+        super(java_type)
         @impl, @plugin, @java_type = impl, plugin, java_type
       end
 
@@ -14,10 +14,30 @@ module Jenkins
         @impl.display_name
       end
 
+      def getId()
+        "#{@plugin.name}-#{@impl.name}"
+      end
+
       def getT()
         @java_type
       end
 
+      # TODO: We removed @name from Descriptor (see playground) so we need to use another name.
+      # Just use class name which is in CamelCase.
+      def getConfigPage
+        "/#{name_to_path}/config".tap { |path|
+          puts "getConfigPage -> #{path}"
+        }
+      end
+
+      # TODO: We removed @name from Descriptor (see playground) so we need to use another name.
+      # Just use class name which is in CamelCase.
+      def getGlobalConfigPage
+        "/#{name_to_path}/global".tap { |path|
+          puts "getGlobalConfigPage -> #{path}"
+        }
+      end
+
       def newInstance(request, form)
         properties = JSON.parse(form.toString(2))
         properties.delete("kind")
@@ -34,6 +54,10 @@ module Jenkins
       rescue ArgumentError
         @impl.new
       end
+
+      def name_to_path
+        @impl.name.split('::').join('/')
+      end
     end
 
   end

data/lib/jenkins/model/listener.rb

@@ -1,3 +1,4 @@
+require 'logger'
 
 module Jenkins
   module Model
@@ -6,42 +7,66 @@ module Jenkins
     class Listener
 
       # the underlying hudson.model.TaskListener object
-      attr_reader :native
+      attr_reader :natvie
+      attr_accessor :level
 
       def initialize(native = nil)
         @native = native
+        @level = Logger::DEBUG
       end
 
-      ##
-      # Insert a clickable hyperlink into this tasks's output
-      # @param [String] url the link target
-      # @param [String] text the link content
-      def hyperlink(url, text)
-        @native.hyperlink(url, text)
+      def debug?; @level <= DEBUG; end
+      def info?;  @level <= INFO;  end
+      def warn?;  @level <= WARN;  end
+      def error?; @level <= ERROR; end
+      def fatal?; @level <= FATAL; end
+
+      def debug(msg = nil, &block);   add(Logger::DEBUG,   msg, &block); end
+      def info(msg = nil, &block);    add(Logger::INFO,    msg, &block); end
+      def warn(msg = nil, &block);    add(Logger::WARN,    msg, &block); end
+      def error(msg = nil, &block);   add(Logger::ERROR,   msg, &block); end
+      def fatal(msg = nil, &block);   add(Logger::FATAL,   msg, &block); end
+      def unknown(msg = nil, &block); add(Logger::UNKNOWN, msg, &block); end
+
+      def <<(msg)
+        logger.write(msg.to_s)
       end
 
-      ##
-      # Append a message to the task output.
-      # @param [String] msg the message
-      def log(msg)
-        @native.getLogger().write(msg.to_s)
+    private
+
+      def add(severity, msg = nil, &block)
+        severity ||= Logger::UNKNOWN
+        if msg.nil? && block_given?
+          msg = yield
+        end
+        str = msg2str(msg) + "\n"
+        return true if severity < @level
+        case severity
+        when Logger::DEBUG, Logger::INFO
+          logger.write(str)
+        when Logger::WARN, Logger::ERROR
+          @native.error(str)
+        else
+          @native.fatalError(str)
+        end
       end
 
-      ##
-      # Append an error message to the task output.
-      # @param [String] msg the error message
-      def error(msg)
-        @native.error(msg.to_s)
+      def msg2str(msg)
+        case msg
+        when ::String
+          msg
+        when ::Exception
+          "#{msg.message} (#{msg.class})\n" << (msg.backtrace || []).join("\n")
+        else
+          msg.inspect
+        end
       end
 
-      ##
-      # Append a fatal error message to the task output
-      # @param [String] msg the fatal error message
-      def fatal(msg)
-        @native.fatalError(msg.to_s)
+      def logger
+        @native.getLogger()
       end
 
       Jenkins::Plugin::Proxies.register self, Java.hudson.util.AbstractTaskListener
     end
   end
-end
+end