ruby-bugzilla-nomagick 0.6.4.2

data/bin/bzconsole

@@ -0,0 +1,738 @@
+#! /usr/bin/env ruby
+# -*- coding: utf-8 -*-
+# bzconsole
+# Copyright (C) 2010-2014 Red Hat, Inc.
+#
+# Authors:
+#   Akira TAGOH  <tagoh@redhat.com>
+#
+# This library is free software: you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation, either
+# version 3 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'optparse'
+require 'time'
+require 'yaml'
+require 'rubygems'
+require 'pp'
+require 'uri'
+require 'highline/import'
+
+begin
+  require 'bugzilla/xmlrpc'
+  require 'bugzilla/user'
+  require 'bugzilla/plugin'
+  require 'bugzilla/bug'
+rescue LoadError
+  $:.push(File.join(File.dirname(__FILE__), '..', 'lib'))
+  require 'bugzilla/xmlrpc'
+  require 'bugzilla/user'
+  require 'bugzilla/plugin'
+  require 'bugzilla/bug'
+end
+
+module BzConsole
+  module Utils
+    def get_xmlrpc(conf = {},opts = {})
+      info = conf
+      uri = URI.parse(info[:URL])
+      host = uri.host
+      port = uri.port
+      path = uri.path.empty? ? nil : uri.path
+      proxy_host, proxy_port = get_proxy(info)
+      timeout = opts[:timeout].nil? ? 60 : opts[:timeout]
+      yield host if block_given? # if you want to run some pre hook
+      xmlrpc = Bugzilla::XMLRPC.new(host, port, path, proxy_host, proxy_port, timeout, uri.user, uri.password)
+      [xmlrpc,host]
+    end
+  end
+end
+
+module BzConsole
+
+  class CommandTemplate
+
+    include Utils
+
+    def initialize(plugin)
+      @n_args = 0
+      @defaultyamlfile = File.join(ENV['HOME'], ".bzconsole.yml")
+      @plugin = plugin
+    end # def initialize
+
+    attr_reader :n_args
+
+    def parse(parser, argv, opts)
+      raise RuntimeError, sprintf("No implementation for %s", self.class) if self.class =~ /CommandTemplate/
+
+      parser.on('-h', '--help', 'show this message') {|x| opts[:help] = true}
+
+      read_config(opts)
+      @plugin.run(:parser, nil, parser, argv, opts)
+
+      parser.order(argv)
+    end # def parse
+
+    def do(argv)
+      raise RuntimeError, sprintf("No implementation for %s", self.class)
+    end # def do
+
+    protected
+
+    def read_config(opts)
+      fname = opts[:config].nil? ? @defaultyamlfile : opts[:config]
+      begin
+        conf = YAML.load(File.open(fname).read)
+      rescue Errno::ENOENT
+        conf = {}
+      end
+      conf.each do |k, v|
+        if v.kind_of?(Hash) && v.include?(:Plugin) then
+          load(v[:Plugin])
+        end
+      end
+      conf
+    end # def read_config
+
+    def save_config(opts, conf)
+      fname = opts[:config].nil? ? @defaultyamlfile : opts[:config]
+      if File.exist?(fname) then
+        st = File.lstat(fname)
+        if st.mode & 0600 != 0600 then
+          raise RuntimeError, sprintf("The permissions of %s has to be 0600", fname)
+        end
+      end
+      File.open(fname, "w") {|f| f.chmod(0600); f.write(conf.to_yaml)}
+    end # def save_config
+
+    private
+
+    def get_proxy(info)
+      uri = info[:Proxy] || ENV["http_proxy"]
+      proxy_uri = uri.nil? ? nil : URI.parse(uri)
+      proxy_host = proxy_uri.nil? ? nil : proxy_uri.host
+      proxy_port = proxy_uri.nil? ? nil : proxy_uri.port
+      return proxy_host, proxy_port
+    end
+
+  end # class CommandTemplate
+
+  class Setup < CommandTemplate
+
+    def initialize(plugin)
+      super
+      @n_args = 0
+    end # def initialize
+
+    def parse(parser, argv, opts)
+      parser.banner = sprintf("Usage: %s [global options] setup", File.basename(__FILE__))
+      parser.separator ""
+      parser.separator "Command options:"
+
+      super
+    end # def parse
+
+    def do(argv, opts)
+      template = {
+        "rhbz"=>{
+          :Name=>"Red Hat Bugzilla",
+          :URL=>"https://bugzilla.redhat.com",
+          :User=>"account@example.com",
+          :Password=>"blahblahblah",
+          :ProductAliases=>{
+            'RHEL3'=>'Red Hat Enterprise Linux 3',
+            'RHEL4'=>'Red Hat Enterprise Linux 4',
+            'RHEL5'=>'Red Hat Enterprise Linux 5',
+            'RHEL6'=>'Red Hat Enterprise Linux 6',
+            'Security'=>'Security Response'          
+          },
+          :Plugin=>"ruby-bugzilla/rhbugzilla.rb"
+        },
+        "gnbz"=>{
+          :Name=>"GNOME Bugzilla",
+          :URL=>"https://bugzilla.gnome.org",
+          :User=>"account@example.com",
+          :Password=>"blahblahblah",
+        },
+        "fdobz"=>{
+          :Name=>"FreeDesktop Bugzilla",
+          :URL=>"https://bugs.freedesktop.org",
+          :User=>"account@example.com",
+          :Password=>"blahblahblah",
+        },
+        "mzbz"=>{
+          :Name=>"Mozilla Bugzilla",
+          :URL=>"https://bugzilla.mozilla.org",
+          :User=>"account@example.com",
+          :Password=>"blahblahblah",
+        },
+        "nvbz"=>{
+          :Name=>"Novell Bugzilla",
+          :URL=>"https://bugzilla.novell.com",
+          :User=>"account@example.com",
+          :Password=>"blahblahblah",
+          :ProductAliases=>{
+              'Security'=>'SUSE Security Incidents'
+          },
+          :Plugin=>"ruby-bugzilla/nvbugzilla.rb"
+        }
+      }
+
+      template.each do |k, v|
+        @plugin.run(:pre, v[:URL].sub(/\Ahttps?:\/\//, '').sub(/\/\Z/, ''), :setup, v)
+      end
+
+      fname = opts[:config].nil? ? @defaultyamlfile : opts[:config]
+      if File.exist?(fname) then
+        raise RuntimeError, ".bzconsole.yml already exists. please remove it first to proceed to the next step."
+      end
+      File.open(fname, File::CREAT|File::WRONLY, 0600) do |f|
+        f.write(template.to_yaml)
+      end
+      printf("%s has been created. please modify your account information before operating.\n", fname)
+    end # def do
+
+  end # class Setup
+
+  class Login < CommandTemplate
+
+    def initialize(plugin)
+      super
+      @n_args = 1
+    end # def initialize
+
+    def parse(parser, argv, opts)
+      opts[:output] = File.join(ENV['HOME'], '.ruby-bugzilla-cookie.yml')
+      parser.banner = sprintf("Usage: %s [global options] login [command options] <prefix> ...", File.basename(__FILE__))
+      parser.separator ""
+      parser.separator "Command options:"
+      parser.on('-o', '--output=FILE', 'FILE to store the cookie') {|v| opts[:output] = v}
+
+      super
+    end # def parse
+
+    def do(argv, opts)
+      conf = read_config(opts)
+      conf.freeze
+      cconf = read_config({:config=>opts[:command][:output]})
+      argv.each do |prefix|
+        if prefix.nil? then
+          raise ArgumentError, "No prefix to log in"
+        end
+        unless conf.include?(prefix) then
+          raise RuntimeError, sprintf("No host information for %s", prefix)
+        end
+
+        info = conf[prefix]
+        login = info[:User].nil? ? ask("Bugzilla ID: ") : info[:User]
+        pass = info[:Password].nil? ? ask("Bugzilla password: ") {|q| q.echo = false} : info[:Password]
+
+        xmlrpc,host = get_xmlrpc(conf[prefix],opts)
+        user = Bugzilla::User.new(xmlrpc)
+
+        begin
+          result = user.login({'login'=>login, 'password'=>pass, 'remember'=>true})
+          cconf[host] = xmlrpc.cookie
+          save_config({:config=>opts[:command][:output]}, cconf)
+        rescue XMLRPC::FaultException => e
+          printf("E: %s\n", e.message)
+        end
+      end
+    end # def do
+
+   end # class Login
+
+  class Getbug < CommandTemplate
+
+    def initialize(plugin)
+      super
+
+      @n_args = 1
+    end # def initialize
+
+    def parse(parser, argv, opts)
+      parser.banner = sprintf("Usage: %s [global options] getbug [command options] <prefix:bug number> ...", File.basename(__FILE__))
+      parser.separator ""
+      parser.separator "Command options:"
+      parser.on('-s', '--summary', 'Displays bugs summary only') {opts[:summary] = true}
+      parser.on('-d', '--details', 'Displays detailed bugs information') {opts[:details] = true}
+      parser.on('-a', '--all', 'Displays the whole data in bugs') {opts[:all] = true}
+      parser.on('-y', '--yaml', 'Displays bugs data as YAML') {opts[:yaml] = true}
+      parser.on('-c', '--cache=FILES', 'load results from FILES') { |v| opts[:cache] ||= []; opts[:cache].push(*v.split(','))}
+      parser.on('--anonymous', 'Access to Bugzilla anonymously') {opts[:anonymous] = true}
+
+      super
+    end # def parse
+
+    def do(argv, opts)
+      real_do(argv, opts) do |result|
+        if opts[:command][:summary] == true then
+          printf("Bug#%s, %s, %s[%s, %s] %s\n",
+                 result['id'],
+                 result['product'],
+                 result['component'],
+                 result['status'],
+                 result['severity'],
+                 result['summary'])
+        elsif opts[:command][:details] == true then
+          printf("Bug#%s, %s, %s, %s[%s, %s, %s, %s] %s\n",
+                 result['id'],
+                 result['product'],
+                 result['assigned_to'],
+                 result['component'],
+                 result['status'],
+                 result['resolution'],
+                 result['priority'],
+                 result['severity'],
+                 result['summary'])
+        elsif opts[:command][:yaml] == true then
+          print(result.to_yaml)
+        else
+          printf("Bug#%s - %s\n", result['id'], result['summary'])
+          printf("Status:\t\t%s%s\n", result['status'], !result['resolution'].empty? ? sprintf("[%s]", result['resolution']) : "")
+          printf("Product:\t%s\n", result['product'])
+          printf("Version:\t%s\n", result['version'])
+          printf("Component:\t%s\n", result['component'])
+          printf("Assinged To:\t%s\n", result['assigned_to'])
+          printf("Priority:\t%s\n", result['priority'])
+          printf("Severity:\t%s\n", result['severity'])
+          result.keys.reject {|x| ['id','summary','status','resolution','product','version','component','assigned_to','priority','severity', 'comments'].include?(x)}.each do |x|
+            printf("%s:\t%s\n", x.capitalize, result[x].respond_to?(:to_time) ? result[x].to_time : result[x])
+          end
+          printf("Comments:\t%d\n\n", result['comments'].length)
+          i = 0
+          result['comments'].each do |c|
+            printf("Comment#%d%s %s  %s\n", i, c['is_private'] == true ? "[private]" : "", c['creator'], c['creation_time'].to_time)
+            printf("\n  %s\n\n", c['text'].split("\n").join("\n  "))
+            i += 1
+          end
+        end
+      end
+    end # def do
+
+    private
+
+    def real_do(argv, opts)
+      conf = read_config(opts)
+      conf.freeze
+      argv.each do |bugn|
+        bugn =~ /(.*):(.*)/
+        prefix = $1
+        nna = $2.split(',')
+        if prefix.nil? then
+          raise ArgumentError, sprintf("No prefix specified for Bug#%s", bugn)
+        end
+        unless conf.include?(prefix) then
+          raise RuntimeError, sprintf("No host information for %s", prefix)
+        end
+
+        cache = opts[:command][:cache]
+        resulth = {}
+        nna0 = nna.dup
+        if cache
+          cacheh = {}
+          cache.each do |cache_file|
+            File.open(cache_file) do |f|
+              YAML.load_stream(f) do |e|
+                cacheh[e["id"].to_s] = e
+              end
+            end
+          end
+          resulta,nna1x = nna.zip(cacheh.values_at(*nna)).partition { |k,v| v }
+          resulth = resulta.to_h
+          nna = nna1x.transpose[0]||[]
+        end
+
+        unless nna.empty?
+          info = conf[prefix]
+          if opts[:command][:anonymous] == true then
+            login = nil
+            pass = nil
+          else
+            login = info[:User].nil? ? ask("Bugzilla ID: ") : info[:User]
+            pass = info[:Password].nil? ? ask("Bugzilla password: ") {|q| q.echo = false} : info[:Password]
+          end
+
+          xmlrpc,host = get_xmlrpc(conf[prefix],opts) do |h|
+              @plugin.run(:pre, h, :getbug, opts)
+          end
+
+          user = Bugzilla::User.new(xmlrpc)
+          user.session(login, pass) do
+            bug = Bugzilla::Bug.new(xmlrpc)
+
+            result = nil
+            if opts[:command][:summary] == true then
+              result = bug.get_bugs(nna)
+            elsif opts[:command][:details] == true then
+              result = bug.get_bugs(nna, ::Bugzilla::Bug::FIELDS_DETAILS)
+            else
+              result = bug.get_bugs(nna, nil)
+            end
+            result.each do |r|
+              resulth[r["id"].to_s] = r
+            end
+          end
+        end
+        result = nna0.map { |nn| resulth[nn] }.compact
+
+        @plugin.run(:post, host, :getbug, result)
+
+        result.each do |r|
+          yield r
+        end
+      end
+    end # def real_do
+
+  end # class Getbug
+
+  class Search < CommandTemplate
+
+    def initialize(plugin)
+      super
+
+      @n_args = 1
+    end # def initialize
+
+    def parse(parser, argv, opts)
+      opts[:query] ||= {}
+      parser.banner = sprintf("Usage: %s [global options] search [command options] <prefix> ...", File.basename(__FILE__))
+      parser.separator ""
+      parser.separator "Search options:"
+      parser.on('--alias=ALIASES', 'filter out the result by the alias') {|v| opts[:query][:alias] ||= []; opts[:query][:alias].push(*v.split(','))}
+      parser.on('-a', '--assignee=ASSIGNEES', 'filter out the result by the specific assignees') {|v| opts[:query][:assigned_to] ||= []; opts[:query][:assigned_to].push(*v.split(','))}
+      parser.on('--bug=BUGS', 'filter out the result by the specific bug number') {|v| opts[:query][:id] ||= []; opts[:query][:id].push(*v.split(','))}
+      parser.on('-c', '--component=COMPONENTS', 'filter out the result by the specific components') {|v| opts[:query][:component] ||= []; opts[:query][:component].push(*v.split(','))}
+      parser.on('--create-time=TIME', 'Searches for bugs that were created at this time or later') {|v| opts[:query][:creation_time] = Time.parse(v)}
+      parser.on('--creator=CREATER', 'filter out the result by the specific user who reported bugs') {|v| opts[:query][:creator] ||= []; opts[:query][:creator].push(*v.split(','))}
+      parser.on('--last-change-time=TIME', 'Searches for bugs that were modified at this time or later') {|v| opts[:query][:last_change_time] = Time.parse(v)}
+      parser.on('--op-sys=NAMES', 'filter out the result by the operating system') {|v| opts[:query][:op_sys] ||= []; opts[:query][:op_sys].push(*v.split(','))}
+      parser.on('--platform=PLATFORMS', 'filter out the result by the platform') {|v| opts[:query][:platform] ||= []; opts[:query][:platform].push(*v.split(','))}
+      parser.on('--priority=PRIORITY', 'filter out the result by the priority') {|v| opts[:query][:priority] ||= []; opts[:query][:priority].push(*v.split(','))}
+      parser.on('-p', '--product=PRODUCTS', 'filter out the result by the specific products') {|v| opts[:query][:product] ||= []; opts[:query][:product].push(*v.split(','))}
+      parser.on('--resolution=RESOLUTIONS', 'filter out the result by the resolutions') {|v| opts[:query][:resolution] ||= []; opts[:query][:resolution].push(*v.split(','))}
+      parser.on('--severity=SEVERITY', 'filter out the result by the severity') {|v| opts[:query][:severity] ||= []; opts[:query][:severity].push(*v.split(','))}
+      parser.on('-s', '--status=STATUSES', 'filter out the result by the status') {|v| opts[:query][:status] ||= []; opts[:query][:status].push(*v.split(','))}
+      parser.on('--summary=SUMMARY', 'filter out the result by the summary') {|v| opts[:query][:summary] ||= []; opts[:query][:summary] << v}
+      parser.on('--milestone=MILESTONE', 'filter out the result by the target milestone') {|v| opts[:query][:target_milestone] ||= []; opts[:query][:target_milestone].push(*v.split(','))}
+      parser.on('--whiteboard=STRING', 'filter out the result by the specific words in the status whiteboard') {|v| opts[:query][:whiteboard] ||= []; opts[:query][:whiteboard] << v}
+      parser.separator ""
+      parser.separator "Command options:"
+      parser.on('--short-list', 'Displays bugs summary only') {opts[:summary] = true}
+      parser.on('--detailed-list', 'Displays detailed bugs information') {opts[:details] = true}
+      parser.on('--anonymous', 'Access to Bugzilla anonymously') {opts[:anonymous] = true}
+
+      super
+    end # def parse
+
+    def do(argv, opts)
+      c = 0
+      real_do(argv, opts) do |result|
+        if opts[:command][:summary] == true then
+          printf("Bug#%s, %s, %s[%s, %s] %s\n",
+                 result['id'] || result['bug_id'],
+                 result['product'],
+                 result['component'],
+                 result['status'],
+                 result['severity'],
+                 result['summary'])
+        elsif opts[:command][:details] == true then
+          printf("Bug#%s, %s, %s, %s[%s, %s, %s, %s] %s\n",
+                 result['id'],
+                 result['product'],
+                 result['assigned_to'],
+                 result['component'],
+                 result['status'],
+                 result['resolution'],
+                 result['priority'],
+                 result['severity'],
+                 result['summary'])
+        end
+        c += 1
+      end
+      printf("\n%d bug(s) found\n", c)
+    end # def do
+
+    private
+
+    def real_do(argv, opts)
+      conf = read_config(opts)
+      conf.freeze
+      argv.each do |prefix|
+        unless conf.include?(prefix) then
+          raise RuntimeError, sprintf("No host information for %s", prefix)
+        end
+
+        info = conf[prefix]
+        uri = URI.parse(info[:URL])
+        host = uri.host
+        port = uri.port
+        path = uri.path.empty? ? nil : uri.path
+        if opts[:command][:anonymous] == true then
+          login = nil
+          pass = nil
+        else
+          login = info[:User].nil? ? ask("Bugzilla ID: ") : info[:User]
+          pass = info[:Password].nil? ? ask("Bugzilla password: ") {|q| q.echo = false} : info[:Password]
+        end
+        proxy_host, proxy_port = get_proxy(info)
+        timeout = opts[:timeout].nil? ? 60 : opts[:timeout]
+
+        @plugin.run(:pre, host, :search, opts[:command][:query])
+
+        xmlrpc = Bugzilla::XMLRPC.new(host, port, path, proxy_host, proxy_port, timeout, uri.user, uri.password)
+        user = Bugzilla::User.new(xmlrpc)
+        user.session(login, pass) do
+            bug = Bugzilla::Bug.new(xmlrpc)
+            opts[:command][:query][:product].map! { |x| info.include?(:ProductAliases) && 
+                                                info[:ProductAliases].include?(x) ? info[:ProductAliases][x] : x } if opts[:command][:query].include?(:product)
+
+            result = bug.search(opts[:command][:query])
+
+            @plugin.run(:post, host, :search, result)
+
+            if result.include?('bugs') then
+                result['bugs'].each do |r|
+                    yield r
+                end
+            end
+        end
+      end
+    end # def real_do
+
+  end # class Search
+
+  class Show < CommandTemplate
+
+    def initialize(plugin)
+      super
+
+      @n_args = 1
+    end # def initialize
+
+    def parse(parser, argv, opts)
+      opts[:show] ||= {}
+      opts[:show][:mode] = :component
+      opts[:show][:field] = []
+      parser.banner = sprintf("Usage: %s [global options] show [command options] <prefix> ...", File.basename(__FILE__))
+      parser.separator ""
+      parser.separator "Command options:"
+      parser.on('-f', '--field', 'Displays available field informations') {|v| opts[:show][:mode] = :field}
+      parser.on('--field-name=NAME', 'Displays NAME field information') {|v| opts[:show][:field] << v.split(',')}
+      parser.on('-p', '--product', 'Displays available product names') {|v| opts[:show][:mode] = :product}
+      parser.on('-c', '--component', 'Displays available component names (default)') {|v| opts[:show][:mode] = :component}
+      parser.on('--anonymous', 'Access to Bugzilla anonymously') {opts[:anonymous] = true}
+
+      super
+    end # def parse
+
+    def do(argv, opts)
+      real_do(argv, opts) do |*result|
+        if opts[:command][:show][:mode] == :product then
+          printf("%s\n", result[0])
+        elsif opts[:command][:show][:mode] == :component then
+          printf("%s:\n", result[0])
+          printf("  %s\n", result[1].join("\n  "))
+        end
+      end
+    end # def do
+
+    private
+
+    def real_do(argv, opts)
+      conf = read_config(opts)
+      conf.freeze
+      argv.each do |prefix|
+        unless conf.include?(prefix) then
+          raise RuntimeError, sprintf("No host information for %s", prefix)
+        end
+
+        info = conf[prefix]
+        uri = URI.parse(info[:URL])
+        host = uri.host
+        port = uri.port
+        path = uri.path.empty? ? nil : uri.path
+        if opts[:command][:anonymous] == true then
+          login = nil
+          pass = nil
+        else
+          login = info[:User].nil? ? ask("Bugzilla ID: ") : info[:User]
+          pass = info[:Password].nil? ? ask("Bugzilla password: ") {|q| q.echo = false} : info[:Password]
+        end
+        proxy_host, proxy_port = get_proxy(info)
+        timeout = opts[:timeout].nil? ? 60 : opts[:timeout]
+
+        @plugin.run(:pre, host, :show, opts)
+
+        xmlrpc = Bugzilla::XMLRPC.new(host, port, path, proxy_host, proxy_port, timeout, uri.user, uri.password)
+        user = Bugzilla::User.new(xmlrpc)
+        user.session(login, pass) do
+          if opts[:command][:show][:mode] == :field then
+            bug = Bugzilla::Bug.new(xmlrpc)
+
+            result = bug.fields(opts[:command][:show][:field].flatten)
+
+            @plugin.run(:post, host, :show, result)
+
+          else
+            product = Bugzilla::Product.new(xmlrpc)
+
+            result = product.selectable_products
+
+            @plugin.run(:post, host, :show, result)
+
+            products = result.keys.sort
+            products.each do |p|
+              if opts[:command][:show][:mode] == :product then
+                yield p
+              elsif opts[:command][:show][:mode] == :component then
+                yield p, result[p][0].sort
+              end
+            end
+          end
+        end
+      end
+    end # def real_do
+
+  end # class Show
+
+  class Newbug < CommandTemplate
+
+    def initialize(plugin)
+      super
+
+      @n_args = 1
+    end # def initialize
+
+    def parse(parser, argv, opts)
+      opts[:newbug] = {}
+
+      parser.banner = sprintf("Usage: %s [global options] newbug [command options] <prefix>", File.basename(__FILE__))
+      parser.separator ""
+      parser.separator "Options:"
+      parser.on('-p', '--product=PRODUCT', 'The name of the product the bug is being filed against') {|v| opts[:newbug][:product] = v}
+      parser.on('-c', '--component=COMPONENT', 'The name of the component in PRODUCT') {|v| opts[:newbug][:component] = v}
+      parser.on('-s', '--summary=SUMMARY', 'A brief description of the bug being filed') {|v| opts[:newbug][:summary] = v}
+      parser.on('-v', '--version=VERSION', 'A version of PRODUCT that the bug was found in') {|v| opts[:newbug][:version] = v}
+      parser.on('-d', '--description=DESCRIPTION', 'The initial description for bug') {|v| opts[:newbug][:description] = v}
+      parser.on('--opsys=OPSYS', 'The operating system the bug was discovered on') {|v| opts[:newbug][:op_sys] = v}
+      parser.on('--platform=PLATFORM', 'What type of hardware the bug was experienced on') {|v| opts[:newbug][:platform] = v}
+      parser.on('--priority=PRIORITY', 'What order the bug will be fixed in by the developer') {|v| opts[:newbug][:priority] = v}
+      parser.on('--severity=SEVERITY', 'How severe the bug is') {|v| opts[:newbug][:severity] = v}
+      parser.on('--alias=ALIAS', 'A brief alias for the bug that can be used instead of a bug number') {|v| opts[:newbug][:alias] = v}
+      parser.on('--assigned_to=ASSGINEE', 'A user to assign the bug to') {|v| opts[:newbug][:assigned_to] = v}
+      parser.on('--comment_is_private', 'Make the description to private') {|v| opts[:newbug][:comment_is_private] = true}
+      parser.on('--groups=GROUPS', 'The list of group names to put this bug into') {|v| opts[:newbug][:groups] = v.split(/,/)}
+      parser.on('--qacontact=USER', 'The QA concact to assign the bug to') {|v| opts[:newbug][:qa_contact] = v}
+      parser.on('--status=STATUS', 'The status that the bug should start out as') {|v| opts[:newbug][:status] = v}
+      parser.on('--resolution=RESOLUTION', 'Set the resolution if filing a closed bug') {|v| opts[:newbug][:resolution] = v}
+      parser.on('--targetmilestone=MILESTONE', 'A valid target milestone for PRODUCT') {|v| opts[:newbug][:target_milestone] = v}
+
+      super
+    end # def parse
+
+    def do(argv, opts)
+      real_do(argv, opts) do |res|
+        if res.include?('id') then
+          printf("A bug has been filed as Bug#%s\n", res['id'])
+        else
+          p res
+        end
+      end
+    end # def do
+
+    private
+
+    def real_do(argv, opts)
+      conf = read_config(opts)
+      conf.freeze
+      # not supporting filing a bug to multiple bugzilla
+      prefix = argv[0]
+      unless conf.include?(prefix) then
+        raise RuntimeError, sprintf("No host information for %s", prefix)
+      end
+
+      info = conf[prefix]
+      uri = URI.parse(info[:URL])
+      host = uri.host
+      port = uri.port
+      path = uri.path.empty? ? nil : uri.path
+      login = info[:User].nil? ? ask("Bugzilla ID: ") : info[:User]
+      pass = info[:Password].nil? ? ask("Bugzilla password: ") {|q| q.echo = false} : info[:Password]
+      proxy_host, proxy_port = get_proxy(info)
+      timeout = opts[:timeout].nil? ? 60 : opts[:timeout]
+
+      @plugin.run(:pre, host, :newbug, opts)
+
+      xmlrpc = Bugzilla::XMLRPC.new(host, port, path, proxy_host, proxy_port, timeout, uri.user, uri.password)
+      user = Bugzilla::User.new(xmlrpc)
+      user.session(login, pass) do
+        bug = Bugzilla::Bug.new(xmlrpc)
+
+        result = bug.create(opts[:command][:newbug])
+
+        @plugin.run(:post, host, :newbug, result)
+
+        yield result
+      end
+    end # def real_do
+
+  end # class Newbug
+
+
+end # module BzConsole
+
+begin
+  opts = {}
+  opts[:command] = {}
+  subargv = []
+
+  o = ARGV.options do |opt|
+    opt.banner = sprintf("Usage: %s [global options] <command> ...", File.basename(__FILE__))
+    opt.separator ""
+    opt.separator "Global options:"
+    opt.on('-c', '--config=FILE', 'read FILE as the configuration file.') {|v| opts[:config] = v}
+    opt.on('-t', '--timeout=SEC', 'Set XMLRPC timeout in a second.') {|v| opts[:timeout] = v.to_i}
+    opt.on('-h', '--help', 'show this message') {|x| opts[:help] = true}
+
+    cmds = BzConsole.constants.sort.map {|x| (k = eval("BzConsole::#{x}")).class == Class && x != :CommandTemplate ? x.downcase.to_sym : nil}.compact
+
+    subargv = opt.order(ARGV);
+
+    command = subargv[0]
+
+    if subargv.length > 0 then
+      n = cmds.index(command.to_sym)
+      unless n.nil? then
+        opts[:instance] = eval("BzConsole::#{cmds[n].to_s.capitalize}.new(Bugzilla::Plugin::Template.new)")
+        subargv = opts[:instance].parse(opt, subargv[1..-1], opts[:command])
+      else
+        STDERR.printf("E: Unknown command: %s\n", subargv[0])
+        STDERR.printf("   Available commands: %s\n", cmds.join(' '))
+        exit 1
+      end
+    else
+      opt.separator ""
+      opt.separator "Available commands:"
+      opt.separator sprintf("  %s", cmds.join(' '))
+    end
+
+    if opts[:instance].nil? && subargv.length == 0 ||
+        opts[:help] == true ||
+        subargv.length < opts[:instance].n_args then
+      puts opt.help
+      exit
+    end
+  end
+
+  opts[:instance].do(subargv, opts)
+end