procps-rb 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c55efb3a9bcec1af52ee2a38bc166d5e99b6a876
+  data.tar.gz: 4c5b83ba9f7661a5b9f6d669dc3fda97d94f3af7
+SHA512:
+  metadata.gz: b1b7ac964ac7a9d139e27746c86975c4c7924d0be766472aa1dce420035c214f33ef78aa4ed6dc41a7ce3ac4130191f852930eb6c8b09115a3e5210b97f96d23
+  data.tar.gz: af7fc2691e0775aec77ce954f1438b1191360f76f0e5cc3c6a629baec33465b37ee304276d14a85739a2c264b86c3d4753f6dd6fb9f64f312da692d3b0089088

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/.ruby-version
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.3.1
+before_install: gem install bundler -v 1.11.2

data/Gemfile

@@ -0,0 +1,17 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ps-rb.gemspec
+gemspec
+
+# To use a debugger
+gem 'byebug', group: [:development, :test]
+
+group :development, :test do
+  # You need these
+  gem "rspec"
+  gem "benchmark-ips"
+  gem "sourcify"
+  gem "awesome_print"
+  gem "pry"
+  gem "pry-doc"
+end

data/README.md

@@ -0,0 +1,63 @@
+# Procps
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/procps`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'procps-rb'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install procps-rb
+
+## Usage
+
+```ruby
+
+Procps::PS.new("/bin/ps").select(:pid, :ppid, :rss, :command).where(user: 'root').sort("+rss").to_a
+
+Procps::PS.new("/bin/ps").select(:pid, :ppid, :rss, :command).where(user: 'root').with_args(m: true).take(3)
+
+# => [
+#      {
+#        :pid     => 269,
+#        :ppid    => 1,
+#        :rss     => 127.42M,
+#        :command => /System/Library/Frameworks/CoreServices.framework/Frameworks/Metadata.framework/Versions/A/Support/mds_stores
+#      },
+#      {
+#        :pid     => 83,
+#        :ppid    => 1,
+#        :rss     => 109.88M,
+#        :command => /System/Library/CoreServices/launchservicesd
+#      },
+#      {
+#        :pid     => 175,
+#        :ppid    => 1,
+#        :rss     => 105.12M,
+#        :command => /System/Library/Frameworks/ApplicationServices.framework/Frameworks/CoreGraphics.framework/Resources/WindowServer -daemon
+#      }
+#    ]
+
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/estum/procps-rb.
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "procps"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+require "pry"
+Pry.start
+
+# require "irb"
+# IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/procps/column.rb

@@ -0,0 +1,42 @@
+module Procps
+  class Column
+    attr_reader :header
+    alias :to_s :header
+
+    def initialize(header, cast = nil, &cast_block)
+      @cast = block_given? ? cast_block : cast
+      raise ArgumentError, "a value of the :cast option must respond to a #call method or be nil" unless @cast.nil? || @cast.respond_to?(:call)
+      @header = header.to_s.freeze
+      freeze
+    end
+
+    def call(value)
+      @cast.nil? ? value : @cast.call(value)
+    rescue => e
+      warn e
+      value
+    end
+
+    class Type
+      attr_reader :original
+      alias :to_s :original
+
+      def initialize(value)
+        @original = value
+        normalize if self.class.method_defined?(:normalize)
+      end
+
+      def to_h
+         Hash[instance_variables.map { |name| [name[1..-1].to_sym, instance_variable_get(name)] }]
+      end
+
+      def inspect
+        "<#{self.class}: #{to_h.inspect}>"
+      end
+
+      def self.call(value)
+        new(value)
+      end
+    end
+  end
+end

data/lib/procps/column_types/command.rb

@@ -0,0 +1,24 @@
+require 'procps/column'
+
+module Procps
+  class Command < Column::Type
+    attr_reader :name, :arguments, :title
+    alias :to_s :name
+    alias :args :arguments
+
+    def inspect
+      original
+    end
+
+    protected def normalize
+      if @original =~ /(?<=^\[)(?<name>.+?)(?=\]$)/
+        @name = name
+      elsif @original =~ /^(?<name>[A-Za-z0-9_\-]+): (?<title>.+)$/
+        @name  = name
+        @title = title
+      else
+        @name, *@arguments = Shellwords.split(@original)
+      end
+    end
+  end
+end

data/lib/procps/column_types/memsize.rb

@@ -0,0 +1,31 @@
+require 'procps/column'
+
+module Procps
+  class Memsize < DelegateClass(Integer)
+    def self.call(value)
+      new(value)
+    end
+
+    SUFFIXES = %w(B K M G T)
+
+    def initialize(value)
+      super(value.to_i * 1024)
+    end
+
+    def human
+      step   = 0
+      output = __getobj__.to_f
+
+      while output > 1024
+        step += 1
+        output = output / 1024
+        break if step == SUFFIXES.size
+      end
+
+      fmt = output == output.to_i ? "%d%s" : "%.2f%s"
+      format(fmt, output, SUFFIXES[step])
+    end
+
+    alias :inspect :human
+  end
+end

data/lib/procps/column_types/scheduling_policy.rb

@@ -0,0 +1,20 @@
+require 'procps/column'
+
+module Procps
+  class SchedulingPolicy < Column::Type
+    attr_reader :value
+    alias :to_sym :value
+
+    POLICIES       = %i(SCHED_OTHER SCHED_FIFO SCHED_RR SCHED_BATCH SCHED_ISO SCHED_IDLE).freeze
+    NORMALIZED_MAP = {"TS" => POLICIES[0], "FF" => POLICIES[1], "RR" => POLICIES[2],
+                      "B" => POLICIES[3], "ISO" => POLICIES[4], "IDL" => POLICIES[5],
+                      "?" => :unknown_value, "-" => :not_reported }.freeze
+
+    private_constant :POLICIES
+    private_constant :NORMALIZED_MAP
+
+    protected def normalize
+      @value = @original.is_a?(Integer) ? POLICIES[@original] : NORMALIZED_MAP[@original]
+    end
+  end
+end

data/lib/procps/ps/columns.rb

@@ -0,0 +1,139 @@
+require 'procps/column'
+require 'procps/column_types/command'
+require 'procps/column_types/memsize'
+require 'procps/column_types/scheduling_policy'
+
+module Procps
+  class PS
+    Address    = -> (base = 10, null: "-".freeze) { -> (v) { v.is_a?(String) ? v == null ? nil : v.to_i(base) : v } }
+    Address_10 = Address[]
+    Address_16 = Address[16]
+    # KiB        = -> (v) { v.to_i * 1024 }
+
+    @@columns = {
+      :blocked    => Column.new("BLOCKED"),
+      :bsdstart   => Column.new("START"),
+      :bsdtime    => Column.new("TIME"),
+      :c          => Column.new("C", &:to_f),
+      :caught     => Column.new("CAUGHT"),
+      :cgroup     => Column.new("CGROUP"),
+      :cls        => Column.new("CLS", SchedulingPolicy),
+      :cmd        => Column.new("CMD", Command),
+      :comm       => Column.new("COMMAND"),
+      :command    => Column.new("COMMAND", Command),
+      :cp         => Column.new("CP") { |v| v.to_f / 100_0 }, # tenths of a percent
+      :egid       => Column.new("EGID", &:to_i),
+      :egroup     => Column.new("EGROUP"),
+      :eip        => Column.new("EIP"),
+      :esp        => Column.new("ESP"),
+      :etime      => Column.new("ELAPSED"),
+      :etimes     => Column.new("ELAPSED", &:to_i),
+      :f          => Column.new("F", &:to_i),
+      :fgid       => Column.new("FGID", &:to_i),
+      :fgroup     => Column.new("FGROUP"),
+      :fname      => Column.new("FNAME"),
+      :fuid       => Column.new("FUID", &:to_i),
+      :fuser      => Column.new("FUSER"),
+      :gid        => Column.new("GID", &:to_i),
+      :group      => Column.new("GROUP"),
+      :ignored    => Column.new("IGNORED"),
+      :ipcns      => Column.new("IPCNS", Address_10),
+      :label      => Column.new("LABEL"),
+      :lstart     => Column.new("STARTED"),
+      :lsession   => Column.new("SESSION"),
+      :lwp        => Column.new("LWP", &:to_i),
+      :machine    => Column.new("MACHINE"),
+      :maj_flt    => Column.new("MAJFLT"),
+      :min_flt    => Column.new("MINFLT"),
+      :mntns      => Column.new("MNTNS", Address_10),
+      :netns      => Column.new("NETNS", Address_10),
+      :ni         => Column.new("NI", &:to_i),
+      :nlwp       => Column.new("NLWP", &:to_i),
+      :nwchan     => Column.new("WCHAN", Address_16),
+      :ouid       => Column.new("OWNER", &:to_i),
+      :pending    => Column.new("PENDING"),
+      :pcpu       => Column.new("%CPU", &:to_f),
+      :pgid       => Column.new("PGID", &:to_i),
+      :pgrp       => Column.new("PGRP", &:to_i),
+      :pid        => Column.new("PID", &:to_i),
+      :pidns      => Column.new("PIDNS", &:to_i),
+      :pmem       => Column.new("%MEM", &:to_f),
+      :policy     => Column.new("POL", SchedulingPolicy),
+      :ppid       => Column.new("PPID", &:to_i),
+      :pri        => Column.new("PRI", &:to_i),
+      :psr        => Column.new("PSR", &:to_i),
+      :rgid       => Column.new("RGID", &:to_i),
+      :rgroup     => Column.new("RGROUP"),
+      :rss        => Column.new("RSS", Memsize),
+      :rtprio     => Column.new("RTPRIO", Address_10),
+      :ruid       => Column.new("RUID", &:to_i),
+      :ruser      => Column.new("RUSER"),
+      :s          => Column.new("S"),
+      :sched      => Column.new("SCH") { |v| SchedulingPolicy.(v.to_i) },
+      :seat       => Column.new("SEAT"),
+      :sess       => Column.new("SESS", &:to_i),
+      :sgi_p      => Column.new("SGI_P", Address[null: "*".freeze]),
+      :sgid       => Column.new("SGID", &:to_i),
+      :sgroup     => Column.new("SGROUP"),
+      :sid        => Column.new("SID", &:to_i),
+      :size       => Column.new("SIZE", &:to_i),
+      :slice      => Column.new("SLICE"),
+      :spid       => Column.new("SPID", &:to_i),
+      :stackp     => Column.new("STACKP", Address_16),
+      :start      => Column.new("STARTED"),
+      :start_time => Column.new("START_TIME"),
+      :stat       => Column.new("STAT"),
+      :suid       => Column.new("SUID", &:to_i),
+      :suser      => Column.new("SUSER"),
+      :supgid     => Column.new("SUPGID", &:to_i),
+      :supgrp     => Column.new("SUPGRP"),
+      :svgid      => Column.new("SVGID", &:to_i),
+      :svuid      => Column.new("SVUID", &:to_i),
+      :sz         => Column.new("SZ", &:to_i),
+      :tgid       => Column.new("TGID", &:to_i),
+      :thcount    => Column.new("THCNT", &:to_i),
+      :tid        => Column.new("TID", &:to_i),
+      :time       => Column.new("TIME"),
+      :tname      => Column.new("TTY"),
+      :tpgid      => Column.new("TPGID", &:to_i),
+      :tt         => Column.new("TT"),
+      :ucmd       => Column.new("CMD"),
+      :uid        => Column.new("UID", &:to_i),
+      :unit       => Column.new("UNIT"),
+      :user       => Column.new("USER"),
+      :userns     => Column.new("USERNS", &:to_i),
+      :utsns      => Column.new("UTSNS", &:to_i),
+      :uunit      => Column.new("UUNIT"),
+      :vsz        => Column.new("VSZ", Memsize)
+    }.tap do |cols|
+      cols.update(
+        :'%cpu'     => cols.fetch(:pcpu),
+        :'%mem'     => cols.fetch(:pmem),
+        :args       => cols.fetch(:command),
+        :class      => cols.fetch(:cls),
+        :cputime    => cols.fetch(:time),
+        :flag       => cols.fetch(:f),
+        :flags      => cols.fetch(:f),
+        :nice       => cols.fetch(:ni),
+        :rssize     => cols.fetch(:rss),
+        :rsz        => cols.fetch(:rss),
+        :sig        => cols.fetch(:pending),
+        :sig_block  => cols.fetch(:blocked),
+        :sigmask    => cols.fetch(:blocked),
+        :sig_catch  => cols.fetch(:caught),
+        :sigcatch   => cols.fetch(:caught),
+        :sig_ignore => cols.fetch(:ignored),
+        :sigignore  => cols.fetch(:ignored),
+        :state      => cols.fetch(:s),
+        :tty        => cols.fetch(:tt),
+        :ucomm      => cols.fetch(:comm),
+        :uname      => cols.fetch(:user),
+        :vsize      => cols.fetch(:vsz)
+      )
+    end
+
+    def self.columns
+      @@columns
+    end
+  end
+end

data/lib/procps/ps/command_builder.rb

@@ -0,0 +1,44 @@
+require 'shellwords'
+
+module Procps
+  class PS
+    class CommandBuilder
+      def initialize(ps)
+        @ps = ps
+      end
+
+      def call
+        Shellwords.join([@ps.bin_path, *modifiers, *options].compact)
+      end
+
+      def modifiers
+        @modifiers ||= @ps.modifiers.size > 0 ? @ps.modifiers.to_a * "" : nil
+      end
+
+      def options
+        @options ||= begin
+          @ps.options.flat_map do |opt, value|
+            case value
+            when false then nil
+            when true  then normalize_option_key(opt)
+                       else [normalize_option_key(opt), normalize_option_value(value)]
+            end
+          end
+        end
+      end
+
+      private
+
+      def normalize_option_key(opt)
+        opt.size == 1 ? "-#{opt}" : "--#{opt}"
+      end
+
+      def normalize_option_value(value)
+        case value
+        when Array then value.join(",")
+                   else value.to_s
+        end
+      end
+    end
+  end
+end

data/lib/procps/ps.rb

@@ -0,0 +1,116 @@
+require 'procps/ps/columns'
+require 'procps/ps/command_builder'
+
+module Procps
+  class PS
+    DEFAULT_BIN_PATH = "/usr/bin/ps"
+    DEFAULT_COLUMNS  = %i(pid rss pcpu)
+
+    attr_accessor :bin_path, :options, :modifiers
+
+    def initialize(bin_path = nil)
+      @bin_path  = bin_path || DEFAULT_BIN_PATH
+      @options   = { o: [] }
+      @modifiers = Set.new
+    end
+
+    def sum
+      @modifiers << "S"
+      self
+    end
+
+    def select(*columns)
+      @options[:o].concat(columns)
+      self
+    end
+
+    def where(
+        command: nil,
+        group: nil,
+        user: nil,
+        pid: nil,
+        ppid: nil,
+        sid: nil,
+        tty: nil,
+        real_group: nil,
+        real_user: nil
+      )
+      @options[:C]    = Array(command)    if command
+      @options[:g]    = Array(group)      if group
+      @options[:u]    = Array(user)       if user
+      @options[:p]    = Array(pid)        if pid
+      @options[:ppid] = Array(ppid)       if ppid
+      @options[:s]    = Array(sid)        if sid
+      @options[:t]    = Array(tty)        if tty
+      @options[:G]    = Array(real_group) if real_group
+      @options[:U]    = Array(real_user)  if real_user
+      self
+    end
+
+    def limit(n)
+      @limit = n
+      self
+    end
+
+    def take(n = 1)
+      limit(n).to_a
+    end
+
+    def with_args(**args)
+      @options.merge!(args)
+      self
+    end
+
+    def sort(*orders)
+      (@options[:sort] ||= []).concat(orders)
+      self
+    end
+
+    def reset
+      @result = nil
+      self
+    end
+
+    def load
+      @result ||= exec_command
+    end
+
+    alias :to_a :load
+
+    def columns
+      @columns ||= @options[:o].map(&@@columns)
+    end
+
+    private
+
+    def to_command
+      @command ||= begin
+        @options[:o].concat(DEFAULT_COLUMNS) unless @options[:o].size > 0
+        CommandBuilder.new(self).call
+      end
+    end
+
+    def exec_command
+      p to_command
+
+      headers, *rows = IO.popen(to_command, "r") do |io|
+        io.readlines
+      end
+
+      rows.replace(rows.take(@limit)) if @limit
+
+      # headers = headers.split(/\s+/, columns.size)
+      rows.map! do |row|
+        parse_result_row(row)
+      end
+    end
+
+    def parse_result_row(row)
+      process = {}
+      row.strip.split(/\s+/, columns.size).each_with_index do |col, i|
+        process[@options[:o][i]] = columns[i].(col)
+      end
+      process
+    end
+  end
+end

data/lib/procps/version.rb

@@ -0,0 +1,3 @@
+module Procps
+  VERSION = "0.0.1"
+end

data/lib/procps-rb.rb

@@ -0,0 +1 @@
+require "procps"

data/lib/procps.rb

@@ -0,0 +1,5 @@
+require "procps/ps"
+require "procps/version"
+
+module Procps
+end

data/procps-rb.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'procps/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "procps-rb"
+  spec.version       = Procps::VERSION
+  spec.authors       = ["Anton Semenov"]
+  spec.email         = ["anton.estum@gmail.com"]
+
+  spec.summary       = %q{Ruby procps wrapper.}
+  spec.description   = %q{Ruby procps wrapper.}
+  spec.homepage      = "https://github.com/estum/procps-rb"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification
+name: procps-rb
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Anton Semenov
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-05-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: Ruby procps wrapper.
+email:
+- anton.estum@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/procps-rb.rb
+- lib/procps.rb
+- lib/procps/column.rb
+- lib/procps/column_types/command.rb
+- lib/procps/column_types/memsize.rb
+- lib/procps/column_types/scheduling_policy.rb
+- lib/procps/ps.rb
+- lib/procps/ps/columns.rb
+- lib/procps/ps/command_builder.rb
+- lib/procps/version.rb
+- procps-rb.gemspec
+homepage: https://github.com/estum/procps-rb
+licenses:
+- MIT
+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.5.1
+signing_key: 
+specification_version: 4
+summary: Ruby procps wrapper.
+test_files: []
+has_rdoc: