roust 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 513086117718e9f68a4940b63d82d3546b1c999e
+  data.tar.gz: efa3079add7548468976c137b1b1cfb40525df21
+SHA512:
+  metadata.gz: 4ccafda8340e695d70354798db29f7338828a2fa5d932ccb9bf8803a8aba0035ee109dbace9175d2dc78b177ddf10f9557238e503b09cd26d237a20a558e3b0c
+  data.tar.gz: c1719e2fb75e59ffba44f05e5b5c24a98faa42fb625137a169a3b74063b46c45f27ac24d9847391e87999954fdf56b557c92ec9736da2fe49b6bc1592ceaef32

data/.gitignore

@@ -0,0 +1,21 @@
+*.gem
+*.rbc
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.rtclientrc
+*.cookie
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/
+

data/.ruby-version

@@ -0,0 +1 @@
+2.0.0-p247

data/Gemfile

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+source 'https://rubygems.org'
+
+gemspec
+
+group :development do
+  gem 'rspec'
+  gem 'colorize'
+  gem 'rake'
+  gem 'webmock'
+end

data/Gemfile.lock

@@ -0,0 +1,55 @@
+PATH
+  remote: .
+  specs:
+    roust (1.0.0)
+      archive-tar-minitar (>= 0.5)
+      mail (>= 2.5.4)
+      mime-types (>= 1.16)
+      nokogiri (>= 1.2)
+      rest-client (>= 0.9)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.3.5)
+    archive-tar-minitar (0.5.2)
+    colorize (0.5.8)
+    crack (0.4.1)
+      safe_yaml (~> 0.9.0)
+    diff-lcs (1.1.3)
+    mail (2.5.4)
+      mime-types (~> 1.16)
+      treetop (~> 1.4.8)
+    mime-types (1.25)
+    mini_portile (0.5.1)
+    nokogiri (1.6.0)
+      mini_portile (~> 0.5.0)
+    polyglot (0.3.3)
+    rake (10.1.0)
+    rest-client (1.6.7)
+      mime-types (>= 1.16)
+    rspec (2.9.0)
+      rspec-core (~> 2.9.0)
+      rspec-expectations (~> 2.9.0)
+      rspec-mocks (~> 2.9.0)
+    rspec-core (2.9.0)
+    rspec-expectations (2.9.1)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.9.0)
+    safe_yaml (0.9.7)
+    treetop (1.4.15)
+      polyglot
+      polyglot (>= 0.3.1)
+    webmock (1.17.1)
+      addressable (>= 2.2.7)
+      crack (>= 0.3.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  colorize
+  rake
+  roust!
+  rspec
+  webmock

data/LICENSE

@@ -0,0 +1,14 @@
+Copyright 2009-2013 Tom Lahti
+Copyright 2014 Bulletproof Networks
+
+Licensed 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.

data/README.md

@@ -0,0 +1,103 @@
+Roust
+=====
+
+Roust is a Ruby client for [Request Tracker](http://www.bestpractical.com/rt/)'s REST API.
+
+It is a fork of [rt-client](http://rubygems.org/gems/rt-client) by Tom Lahti.
+
+Features
+--------
+
+- Ticket querying using the full RT query language
+- Fetching ticket metadata (id, subject, queue, etc)
+- Fetching transactions on individual tickets (in long and short form)
+- Fetching user details
+
+Installing
+----------
+
+Ensure you have Ruby > 1.9 installed, then run:
+
+```
+gem install roust
+```
+
+Or add to your Gemfile:
+
+``` ruby
+gem 'roust', :git => 'git@github.com:bulletproofnetworks/roust.git'
+```
+
+Using
+-----
+
+``` ruby
+require 'roust'
+
+credentials = {
+  :server   => 'http://rt.example.org',
+  :username => 'admin'
+  :password => 's3cr3t'
+}
+
+rt = Roust.new(credentials)
+rt.authenticated? # => true
+
+# Query RT 
+rt.list(:query => "id = 1 or id = 2") # => [["1", "A subject"], ["2", "Another subject"]]
+
+# Fetch ticket metadata
+rt.show("1") # => { {"cc"=>["dan@us.example", "dave@them.example"], "owner"=>"bob", "creator"=>"alice", "status"=>"open", … }
+
+# Fetch ticket transactions
+rt.history("1", :format => "short") # => [["1", "Ticket created by alice"], ["2", "Status changed from 'open' to 'resolved' by bob"]]
+rt.history("1", :format => "long") # => [{"id"=>"1", "ticket"=>"1", "timetaken"=>"0", "type"=>"Create", "field"=>"", "oldvalue"=>"", "newvalue"=>"", "data"=>"", "description"=>"Ticket created by alice" }, … ]
+
+# Fetch user details
+rt.user("dan@us.example") # => {"id"=>"user/160000", "name"=>"dan", "password"=>"********", "emailaddress"=>"dan@us.example", "realname"=>"Dan Smith", "nickname"=>"dan", … }
+```
+
+
+Developing
+----------
+
+To get started, clone the Roust repository locally by running:
+
+```
+git clone git@github.com:bulletproofnetworks/roust.git
+```
+
+Then pull in the dependencies:
+
+```
+bundle
+```
+
+You're now ready to run the tests:
+
+```
+bundle exec rake
+```
+
+Roust has reasonable test coverage of the core features mentioned above. It has some other features that have been ported from the original rt-client implementation that are not tested (and are probably broken). See the TODO section for more details.
+
+
+Releasing
+---------
+
+1. Bump the version in `lib/roust/version.rb`
+2. Add an entry to `CHANGELOG.md`
+3. Run a `bundle` to update any RubyGems dependencies.
+4. `git commit` everything.
+5. git tag the version git tag X.Y.Z
+6. Build the gem with `rake build`
+
+
+
+TODO
+----
+
+- Links CRUD (linking tickets to one another)
+- User CRUD (creating + updating + deleting users)
+- Ticket comment + correspondence
+- Attachment fetching

data/Rakefile

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'rspec/core/rake_task'
+require 'colorize'
+
+RSpec::Core::RakeTask.new('spec')
+
+desc "build gem"
+task :build do
+  build_output = `gem build roust.gemspec`
+  puts build_output
+
+  gem_filename = build_output[/File: (.*)/,1]
+  pkg_path = "pkg"
+  FileUtils.mkdir_p(pkg_path)
+  FileUtils.mv(gem_filename, pkg_path)
+
+  puts "Gem built in #{pkg_path}/#{gem_filename}".green
+end
+
+desc "push gem"
+task :push do
+  filenames = Dir.glob("pkg/*.gem")
+  filenames_with_times = filenames.map do |filename|
+    [filename, File.mtime(filename)]
+  end
+
+  newest = filenames_with_times.sort_by { |tuple| tuple.last }.last
+  newest_filename = newest.first
+
+  command = "gem push #{newest_filename}"
+  system(command)
+end
+
+task :default => [:spec]
+

data/examples/example.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'rt/client' # requires ruby 1.8
+require 'pp'
+
+
+ticket_id = '1318622'
+parent_id = '1258480'
+
+rt = RT_Client.new
+
+rt.add_link(:id => ticket_id, :MemberOf => parent_id)
+links = rt.links(:id => ticket_id)
+pp links

data/lib/roust/rtxmlsrv.rb

@@ -0,0 +1,271 @@
+#!/opt/ruby-enterprise-1.8.7-2010.02/bin/ruby
+
+## XML RPC service to provide a cross-platform API for
+## RT ticket creation/maintenance.  Essentially just a wrapper
+## around the rt/client library.
+
+require "rubygems"             # so we can load gems
+require "rt/client"            # rt-client REST library
+require "xmlrpc/server"        # that's what we're doing
+require "date"                 # for parsing arbitrary date formats
+require "pp"
+
+PORT=8080
+MAX_CONN=50
+
+# extend the Hash class to 
+# translate string keys into symbol keys
+class Hash # :nodoc:
+  def remapkeys!
+    n = Hash.new
+    self.each_key do |key|
+      n[key.to_sym] = self[key]
+    end
+    self.replace(n)
+    n = nil
+    $stderr.puts self.map { |k,v| "#{k} => #{v}" }
+    self
+  end
+end
+
+class TicketSrv
+
+  def initialize
+  end
+  
+  INTERFACE = XMLRPC::interface("rt") {
+    meth 'string add_watcher(struct)','Calls RT_Client::add_watcher'
+    meth 'array attachments(struct)','Calls RT_Client::attachments'
+    meth 'string comment(struct)','Calls RT_Client::comment'
+    meth 'string correspond(struct)','Calls RT_Client::correspond'
+    meth 'string create(struct)','Calls RT_Client::create'
+    meth 'string create_user(struct)','Calls RT_Client::create_user'
+    meth 'string edit(struct)','Calls RT_Client::edit'
+    meth 'string edit_or_create_user(struct)','Calls RT_Client::edit_or_create_user'
+    meth 'struct get_attachment(struct)','Calls RT_Client::get_attachment'
+    meth 'struct history(struct)','Calls RT_Client::history (long form)'
+    meth 'struct history_item(struct)','Calls RT_Client::history_item'
+    meth 'array list(struct)','Calls RT_Client::list'
+    meth 'array query(struct)','Calls RT_Client::query (long form)'
+    meth 'struct show(struct)','Calls RT_Client::show'
+  }
+
+  # Allows watchers to be added via RT_Client::add_watcher
+  # You need to pass :id, :addr, and optionally :type
+  def add_watcher(struct)
+    struct.remapkeys!
+    if struct.has_key? :user and struct.has_key? :pass
+      rt = RT_Client.new(:user => struct[:user], :pass => struct[:pass])
+    else
+      rt = RT_Client.new
+    end
+    val = rt.add_watcher(struct)
+    rt = nil
+    val
+  end
+
+  # Gets a list of attachments via RT_Client::attachments
+  # You need to pass :id, and optionally :unnamed
+  def attachments(struct)
+    struct.remapkeys!
+    if struct.has_key? :user and struct.has_key? :pass
+      rt = RT_Client.new(:user => struct[:user], :pass => struct[:pass])
+    else
+      rt = RT_Client.new
+    end
+    rt = RT_Client.new
+    val = rt.attachments(struct)
+    rt = nil
+    val
+  end
+
+  # Adds comments to tickets via RT_Client::comment
+  def comment(struct)
+    struct.remapkeys!
+    if struct.has_key? :user and struct.has_key? :pass
+      rt = RT_Client.new(:user => struct[:user], :pass => struct[:pass])
+    else
+      rt = RT_Client.new
+    end
+    val = rt.comment(struct)
+    rt = nil
+    val
+  end
+
+  # Allows new tickets to be created via RT_Client::correspond
+  def correspond(struct)
+    struct.remapkeys!
+    if struct.has_key? :user and struct.has_key? :pass
+      rt = RT_Client.new(:user => struct[:user], :pass => struct[:pass])
+    else
+      rt = RT_Client.new
+    end
+    val = rt.correspond(struct)
+    rt = nil
+    val
+  end
+
+  # Allows new tickets to be created via RT_Client::create
+  def create(struct)
+    struct.remapkeys!
+    if struct.has_key? :user and struct.has_key? :pass
+      rt = RT_Client.new(:user => struct[:user], :pass => struct[:pass])
+    else
+      rt = RT_Client.new
+    end
+    val = rt.create(struct)
+    rt = nil
+    val
+  end
+
+  # Allows new users to be created via RT_Client::create_user
+  def create_user(struct)
+    struct.remapkeys!
+    if struct.has_key? :user and struct.has_key? :pass
+      rt = RT_Client.new(:user => struct[:user], :pass => struct[:pass])
+    else
+      rt = RT_Client.new
+    end
+    val = rt.create_user(struct)
+    rt = nil
+    val
+  end
+
+  # Find RT user details from email address via RT_Cleint::usersearch
+  def usersearch(struct)
+    struct.remapkeys!
+    if struct.has_key? :user and struct.has_key? :pass
+      rt = RT_Client.new(:user => struct[:user], :pass => struct[:pass])
+    else
+      rt = RT_Client.new
+    end
+    val = rt.usersearch(struct)
+    rt = nil
+    val
+  end
+
+  # Allows new users to be edited or created if they don't exist
+  def edit_or_create_user(struct)
+    struct.remapkeys!
+    if struct.has_key? :user and struct.has_key? :pass
+      rt = RT_Client.new(:user => struct[:user], :pass => struct[:pass])
+    else
+      rt = RT_Client.new
+    end
+    val = rt.edit_or_create_user(struct)
+    rt = nil
+    val
+  end
+
+  # Allows existing ticket to be modified via RT_Client::edit
+  def edit(struct)
+    struct.remapkeys!
+    if struct.has_key? :user and struct.has_key? :pass
+      rt = RT_Client.new(:user => struct[:user], :pass => struct[:pass])
+    else
+      rt = RT_Client.new
+    end
+    val = rt.edit(struct)
+    rt = nil
+    val
+  end
+
+  # Retrieves attachments via RT_Client::get_attachment
+  def get_attachment(struct)
+    struct.remapkeys!
+    if struct.has_key? :user and struct.has_key? :pass
+      rt = RT_Client.new(:user => struct[:user], :pass => struct[:pass])
+    else
+      rt = RT_Client.new
+    end
+    val = rt.get_attachment(struct)
+    rt = nil
+    val
+  end
+
+  # Gets the history of a ticket via RT_Client::history
+  def history(struct)
+    struct.remapkeys!
+    if struct.has_key? :user and struct.has_key? :pass
+      rt = RT_Client.new(:user => struct[:user], :pass => struct[:pass])
+    else
+      rt = RT_Client.new
+    end
+    val = rt.history(struct)
+    rt = nil
+    val
+  end
+
+  # Gets a single history item via RT_Client::history_item
+  def history_item(struct)
+    struct.remapkeys!
+    if struct.has_key? :user and struct.has_key? :pass
+      rt = RT_Client.new(:user => struct[:user], :pass => struct[:pass])
+    else
+      rt = RT_Client.new
+    end
+    val = rt.history_item(struct)
+    rt = nil
+    val
+  end
+
+  # Gets a list of tickets via RT_Client::list
+  def list(struct)
+    struct.remapkeys!
+    if struct.has_key? :user and struct.has_key? :pass
+      rt = RT_Client.new(:user => struct[:user], :pass => struct[:pass])
+    else
+      rt = RT_Client.new
+    end
+    val = rt.list(struct)
+    rt = nil
+    val
+  end
+
+  # Gets a list of tickets via RT_Client::query
+  def query(struct)
+    struct.remapkeys!
+    if struct.has_key? :user and struct.has_key? :pass
+      rt = RT_Client.new(:user => struct[:user], :pass => struct[:pass])
+    else
+      rt = RT_Client.new
+    end
+    val = rt.query(struct)
+    rt = nil
+    val
+  end
+
+  # Gets detail (minus history/attachments) via RT_Client::show
+  def show(struct)
+    struct.remapkeys!
+    if struct.has_key? :user and struct.has_key? :pass
+      rt = RT_Client.new(:user => struct[:user], :pass => struct[:pass])
+    else
+      rt = RT_Client.new
+    end
+    val = rt.show(struct)
+    rt = nil
+    val
+  end
+  
+end # class TicketSrv
+
+pid = fork do
+  Signal.trap('HUP','IGNORE')
+  # set up a log file
+  logfile = File.dirname(__FILE__) + "/ticketsrv.log"
+  accfile = File.dirname(__FILE__) + "/access.log"
+  acc = File.open(accfile,"a+")
+  $stderr.reopen acc # redirect $stderr to the log as well
+  # determine the IP address to listen on and create the server
+  sock = Socket.getaddrinfo(Socket.gethostname,PORT,Socket::AF_INET,Socket::SOCK_STREAM)
+  $s = XMLRPC::Server.new(sock[0][1], sock[0][3], MAX_CONN, logfile)
+  $s.set_parser(XMLRPC::XMLParser::XMLStreamParser.new)
+  $s.add_handler(TicketSrv::INTERFACE, TicketSrv.new)
+  $s.add_introspection
+  $s.serve  # start serving
+  $stderr.reopen STDERR
+  acc.close
+end
+Process.detach(pid)
+                              

data/lib/roust/version.rb

@@ -0,0 +1,3 @@
+class Roust
+  VERSION = '1.0.0'
+end