satyr 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b52e512f3fb48bce3031e8d8b88ee0764fcc8f02
+  data.tar.gz: 85e6bef907ae38f51c744df06443402f87f61c83
+SHA512:
+  metadata.gz: 9e7150a99c1df538f986fc7150f6c4ddf9b5a4fe7c5b05909211964358098d2dd12efd7780e180cecd23fa79353e84c10d8ccc08e7285c148ad26b7347130bd1
+  data.tar.gz: 22f78ab04653c4504f4c9b30b982c450bee87967d43871102f5460200a4635b771b6690d9e1f88c871267c43787f3c1d0e2348b03d1d3c15761994f31a34baf1

data/Rakefile

@@ -0,0 +1,8 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+    t.libs << 'test'
+end
+
+desc "Run tests"
+task :default => :test

data/lib/satyr.rb

@@ -0,0 +1,176 @@
+require 'ffi'
+
+# Ruby bindings for libsatyr
+module Satyr
+
+  # FFI wrappers for C functions. <em>Do not use this module directly</em>
+  module FFI
+    extend ::FFI::Library
+
+    ffi_lib 'libsatyr.so.3', ::FFI::Library::LIBC
+
+    enum :report_type, [ :invalid, 0,
+                         :core,
+                         :python,
+                         :kerneloops,
+                         :java,
+                         :gdb ]
+
+    enum :duphash_flags, [ :normal, 1 << 0,
+                           :nohash, 1 << 1,
+                           :nonormalize, 1 << 2,
+                           :koops_compat, 1 << 3 ]
+
+    attach_function :sr_report_from_json_text, [:string, :pointer], :pointer
+    attach_function :sr_report_free, [:pointer], :void
+
+    attach_function :sr_stacktrace_find_crash_thread, [:pointer], :pointer
+    attach_function :sr_core_stacktrace_dup, [:pointer], :pointer
+    attach_function :sr_python_stacktrace_dup, [:pointer], :pointer
+    attach_function :sr_koops_stacktrace_dup, [:pointer], :pointer
+    attach_function :sr_java_stacktrace_dup, [:pointer], :pointer
+    attach_function :sr_gdb_stacktrace_dup, [:pointer], :pointer
+    attach_function :sr_stacktrace_free, [:pointer], :void
+
+    attach_function :sr_thread_dup, [:pointer], :pointer
+    attach_function :sr_thread_get_duphash, [:pointer, :int, :string, :duphash_flags], :pointer
+    attach_function :sr_thread_free, [:pointer], :void
+
+    attach_function :free, [:pointer], :void
+
+    class ReportStruct < ::FFI::ManagedStruct
+      layout :version, :uint32,
+        :type, :report_type,
+        :reporter_name, :string,
+        :reporter_version, :string,
+        :user_root, :bool,
+        :user_local, :bool,
+        :operating_system, :pointer,
+        :component_name, :string,
+        :rpm_packages, :pointer,
+        :stacktrace, :pointer
+
+      def self.release(pointer)
+        Satyr::FFI.sr_report_free pointer
+      end
+    end
+
+    class StacktraceStruct < ::FFI::ManagedStruct
+      layout :type, :report_type
+
+      def self.release(pointer)
+        Satyr::FFI.sr_stacktrace_free pointer
+      end
+    end
+
+    class ThreadStruct < ::FFI::ManagedStruct
+      layout :type, :report_type
+
+      def self.release(pointer)
+        Satyr::FFI.sr_thread_free pointer
+      end
+    end
+
+  end
+
+  # Exception for errors originating in satyr
+  class SatyrError < StandardError
+  end
+
+  # Report containing all data relevant to a software problem
+  class Report
+
+    # Parses given JSON string to create new Report
+    def initialize(json)
+      error_msg = ::FFI::MemoryPointer.new(:pointer, 1)
+      pointer = Satyr::FFI.sr_report_from_json_text json.to_s, error_msg
+      error_msg = error_msg.read_pointer
+      unless error_msg.null?
+        message = error_msg.read_string.force_encoding('UTF-8')
+        Satyr::FFI.free error_msg
+        raise SatyrError, "Failed to parse JSON: #{message}"
+      end
+
+      # from_json_text should never return NULL without setting error_msg,
+      # better err on the safe side though
+      raise SatyrError, "Failed to create stacktrace" if pointer.null?
+
+      @struct = Satyr::FFI::ReportStruct.new pointer
+    end
+
+    # Returns Stacktrace of the report
+    def stacktrace
+      stacktrace = @struct[:stacktrace]
+      return nil if stacktrace.null?
+
+      # There's no sr_stacktrace_dup in libsatyr.so.3, we've got to find out
+      # the type ourselves.
+      dup = case @struct[:type]
+      when :core
+        Satyr::FFI.sr_core_stacktrace_dup(stacktrace)
+      when :python
+        Satyr::FFI.sr_python_stacktrace_dup(stacktrace)
+      when :kerneloops
+        Satyr::FFI.sr_koops_stacktrace_dup(stacktrace)
+      when :java
+        Satyr::FFI.sr_java_stacktrace_dup(stacktrace)
+      when :gdb
+        Satyr::FFI.sr_gdb_stacktrace_dup(stacktrace)
+      else
+        raise SatyrError, "Invalid report type"
+      end
+
+      raise SatyrError, "Failed to obtain stacktrace" if dup.null?
+
+      Stacktrace.send(:new, dup)
+    end
+  end
+
+  # Program stack trace, possibly composed of multiple threads
+  class Stacktrace
+
+    # Private constructor - Stacktrace objects are created in Report#stacktrace
+    def initialize(pointer)
+      raise SatyrError, "Invalid structure" if pointer.null?
+      @struct = Satyr::FFI::StacktraceStruct.new pointer
+    end
+    private_class_method :new
+
+    # Returns Thread that likely caused the crash that produced this stack
+    # trace
+    def find_crash_thread
+      pointer = Satyr::FFI.sr_stacktrace_find_crash_thread @struct.to_ptr
+      raise SatyrError, "Could not find crash thread" if pointer.null?
+      dup = Satyr::FFI.sr_thread_dup(pointer)
+      raise SatyrError, "Failed to duplicate thread" if dup.null?
+
+      Thread.send(:new, dup)
+    end
+  end
+
+  # Thread in a stack trace containing individual stack frames
+  class Thread
+
+    # Private constructor - Thread objects are returned by Stacktrace methods
+    def initialize(pointer)
+      raise SatyrError, "Invalid structure" if pointer.null?
+      @struct = Satyr::FFI::ThreadStruct.new pointer
+    end
+    private_class_method :new
+
+    # Duplication hash for the thread
+    # The method takes an option hash with following keys:
+    # - +:frames+:: number of frames to use (default 0 means use all)
+    # - +:flags+:: bitwise sum of (:normal, :nohash, :nonormalize,
+    #              :koops_compat)
+    # - +:prefix+:: string to be prepended in front of the text before hashing
+    def duphash(opts = {})
+      opts = {:frames => 0, :flags => :normal, :prefix => ""}.merge(opts)
+      str_pointer = Satyr::FFI.sr_thread_get_duphash @struct.to_ptr, opts[:frames], opts[:prefix], opts[:flags]
+      raise SatyrError, "Failed to compute duphash" if str_pointer.null?
+      hash = str_pointer.read_string.force_encoding('UTF-8')
+      Satyr::FFI.free str_pointer
+      hash
+    end
+  end
+end

data/test/data/ureport-1

@@ -0,0 +1,107 @@
+{
+  "ureport_version": 2,
+
+  "reason": "Program /usr/bin/sleep was terminated by signal 11",
+
+  "os": {
+    "name": "fedora",
+    "version": "18",
+    "architecture": "x86_64"
+  },
+
+  "problem": {
+    "type": "core",
+
+    "executable": "/usr/bin/sleep",
+
+    "signal": 11,
+
+    "component": "coreutils",
+
+    "user": {
+      "local": true,
+      "root": false
+    },
+
+    "stacktrace": [
+      {
+        "crash_thread": true,
+
+        "frames": [
+          {
+            "build_id": "5f6632d75fd027f5b7b410787f3f06c6bf73eee6",
+            "build_id_offset": 767024,
+            "file_name": "/lib64/libc.so.6",
+            "address": 251315074096,
+            "fingerprint": "6c1eb9626919a2a5f6a4fc4c2edc9b21b33b7354",
+            "function_name": "__nanosleep"
+          },
+          {
+            "build_id": "cd379d3bb5d07c96d491712e41c34bcd06b2ce32",
+            "build_id_offset": 16567,
+            "file_name": "/usr/bin/sleep",
+            "address": 4210871,
+            "fingerprint": "d24433b82a2c751fc580f47154823e0bed641a54",
+            "function_name": "close_stdout"
+          },
+          {
+            "build_id": "cd379d3bb5d07c96d491712e41c34bcd06b2ce32",
+            "build_id_offset": 16202,
+            "file_name": "/usr/bin/sleep",
+            "address": 4210506,
+            "fingerprint": "562719fb960d1c4dbf30c04b3cff37c82acc3d2d",
+            "function_name": "close_stdout"
+          },
+          {
+            "build_id": "cd379d3bb5d07c96d491712e41c34bcd06b2ce32",
+            "build_id_offset": 6404,
+            "fingerprint": "2e8fb95adafe21d035b9bcb9993810fecf4be657",
+            "file_name": "/usr/bin/sleep",
+            "address": 4200708
+          },
+          {
+            "build_id": "5f6632d75fd027f5b7b410787f3f06c6bf73eee6",
+            "build_id_offset": 137733,
+            "file_name": "/lib64/libc.so.6",
+            "address": 251314444805,
+            "fingerprint": "075acda5d3230e115cf7c88597eaba416bdaa6bb",
+            "function_name": "__libc_start_main"
+          }
+        ]
+      }
+    ]
+  },
+
+  "packages": [
+    {
+      "name": "coreutils",
+      "epoch": 0,
+      "version": "8.17",
+      "architecture": "x86_64",
+      "package_role": "affected",
+      "release": "8.fc18",
+      "install_time": 1371464601
+    },
+    {
+      "name": "glibc",
+      "epoch": 0,
+      "version": "2.16",
+      "architecture": "x86_64",
+      "release": "31.fc18",
+      "install_time": 1371464176
+    },
+    {
+      "name": "glibc-common",
+      "epoch": 0,
+      "version": "2.16",
+      "architecture": "x86_64",
+      "release": "31.fc18",
+      "install_time": 1371464184
+    }
+  ],
+
+  "reporter": {
+    "version": "0.3",
+    "name": "satyr"
+  }
+}

data/test/test_satyr.rb

@@ -0,0 +1,43 @@
+require 'test/unit'
+require 'satyr'
+
+class SatyrTest < Test::Unit::TestCase
+  def test_core_duphash
+    path = 'test/data/ureport-1'
+    json = IO.read(path)
+
+    report = Satyr::Report.new json
+    stacktrace = report.stacktrace
+    thread = stacktrace.find_crash_thread
+
+    assert_equal 'b9a440a68b6e0f33f6cd989e114d6c4093964e10', thread.duphash
+
+    expected_out = "Thread\n5f6632d75fd027f5b7b410787f3f06c6bf73eee6+0xbb430\n"
+    assert_equal expected_out, thread.duphash(frames: 1, flags: :nohash)
+
+    expected_out = "a" + expected_out
+    assert_equal expected_out, thread.duphash(frames: 1, flags: :nohash, prefix: "a")
+  end
+
+  def test_invalid_report
+    assert_raise Satyr::SatyrError do
+      report = Satyr::Report.new ""
+    end
+
+    begin
+      report = Satyr::Report.new "}"
+    rescue Satyr::SatyrError => e
+      assert_match /Failed to parse JSON:.*}.*/, e.message
+    end
+  end
+
+  def test_private_constructors
+    assert_raise NoMethodError do
+      s = Satyr::Stacktrace.new nil
+    end
+
+    assert_raise NoMethodError do
+      s = Satyr::Thread.new nil
+    end
+  end
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: satyr
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Martin Milata
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ruby bindings for satyr, library for working with the uReport problem
+  report format.
+email: mmilata@redhat.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/satyr.rb
+- Rakefile
+- test/test_satyr.rb
+- test/data/ureport-1
+homepage: http://github.com/abrt/satyr
+licenses:
+- GPLv2
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.11
+signing_key: 
+specification_version: 4
+summary: Parse uReport bug report format
+test_files:
+- test/test_satyr.rb
+- test/data/ureport-1