process-query-language 0.1.0

data/LICENSE

@@ -0,0 +1,2 @@
+
+You may not use this software. At all.

data/README.md

@@ -0,0 +1,54 @@
+
+Process Query Language
+----------------------
+
+PQL is a query language for processes running on a system. The syntax
+is closely related to the one used in MongoDB. This is because at heart, PQL
+uses Plucky. But instead of sending the queries to a MongoDB server, they
+are intercepted and processed by PQL.
+
+PQL extends the Process class with four new methods:
+
+ * find - find a process by PID
+ * where - find processes which match a query
+ * remove - remove (kill) processes
+ * count - count processes
+
+These `where` method returns a Plucky::Query object. This object
+can be used to further refine the query by chaining additional methods.
+Consult the Plucky documentation to see which methods are available.
+
+
+Supported fields
+----------------
+
+There is a limited number of fields which can be used in queries. The
+following fields are supported:
+
+ :pid, :rss, :command
+
+The following operators are supported
+
+ gt, gte, lt, lte, in, nin
+
+Use of an unknown field or unknown operator will raise an exception.
+
+
+Example
+-------
+
+This will print the number of unicorn rails workers which use more than
+20MB of RSS:
+
+    require 'rubygems'
+    require 'process-query-language'
+    
+    query = Process.where(:rss.gt => 20_000_000)
+    query.where(:command => /unicorn_rails.worker/)
+    puts query.count
+
+
+License
+-------
+
+Copyright (c) 2010 by Tomas "wereHamster" Carnecky (tomas.carnecky@gmail.com)

data/lib/process-query-language.rb

@@ -0,0 +1,34 @@
+
+require 'plucky'
+
+module ProcessQueryLanguage
+
+  autoload :Version,          'process-query-language/version'
+  autoload :Collection,       'process-query-language/collection'
+  autoload :Matcher,          'process-query-language/matcher'
+
+  module Backend
+    autoload :ProcessStatus,  'process-query-language/backend/process-status'
+  end
+
+end
+
+
+module Process
+
+  def self.pql(backend)
+    klass = ProcessQueryLanguage::Backend.const_get(backend)
+    @@pql = ProcessQueryLanguage::Collection.new(klass.new)
+  end
+
+  # Only expose selected methods from the Plucky::Query object
+  %w{ find remove count where }.each do |method|
+    module_eval <<-eval
+      def Process.#{method}(*args)
+        @@pql ||= ProcessQueryLanguage::Collection.new(ProcessQueryLanguage::Backend::ProcessStatus.new)
+        Plucky::Query.new(@@pql).#{method}(*args)
+      end
+    eval
+  end
+
+end

data/lib/process-query-language/backend/process-status.rb

@@ -0,0 +1,47 @@
+
+module ProcessQueryLanguage
+
+  module Backend
+
+    # This backend uses the `ps` utility and parses its output. Because
+    # `ps` uses whitespace as the delimiter (and truncates too wide fields)
+    # except the last, we need to sort the fields so that :command is
+    # the last.
+    class ProcessStatus
+
+      FIELDS = %w{ pid rss command }.map(&:to_sym)
+
+      def scan(fields)
+        result = []
+        %x[ps -Aco #{FIELDS.join(',')}].lines.to_a[1..-1].each do |line|
+          values = line.split(' ')
+          process = {}
+          FIELDS.each_with_index do |value, i|
+            next unless fields.include?(FIELDS[i])
+            process[FIELDS[i]] = convert(FIELDS[i], values[i])
+          end
+          result << process
+        end
+
+        return result
+      end
+
+    private
+
+      def convert(field, value)
+        case field
+        when :rss, :pid
+          return value.to_i
+        when :command
+          return value.to_s
+        else
+          return nil
+          raise Exception.new("Don't know how to convert #{field}")
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/process-query-language/collection.rb

@@ -0,0 +1,42 @@
+
+module ProcessQueryLanguage
+
+  class Collection
+
+    def initialize(backend)
+      @backend = backend
+    end
+
+    def find(query, options)
+      query[:pid] = query.delete(:_id) if query[:_id]
+
+      keys = query.keys
+      keys = keys + options[:fields] if options[:fields]
+
+      matcher = ProcessQueryLanguage::Matcher.new(query)
+      result = []
+      @backend.scan(keys.uniq).each do |process|
+        if matcher.match(process)
+          result << process
+        end
+      end
+
+      return result
+    end
+
+    def find_one(query, options)
+      find(query, options).first
+    end
+
+    def remove(query)
+      find(query, { :fields => [ :pid ] }).each do |process|
+        Process.kill(process[:pid])
+      end
+    end
+
+    def insert
+    end
+
+  end
+
+end

data/lib/process-query-language/matcher.rb

@@ -0,0 +1,56 @@
+
+module ProcessQueryLanguage
+
+  class Matcher
+
+    attr_reader :pattern
+
+    # pattern: { a => { $gt => 100 }, b => { $in => [ 1,2,3 ] } }
+    def initialize(pattern)
+      @pattern = pattern
+    end
+
+    def apply(op, value, pattern)
+      case op
+      when "$gt"
+        return value > pattern
+      when "$gte"
+        return value >= pattern
+      when "$lt"
+        return value < pattern
+      when "$lte"
+        return value <= pattern
+      when "$in"
+        return pattern.include?(value)
+      when "$nin"
+        return !pattern.include?(value)
+      else
+        raise Exception.new("Unknown operator: #{op}")
+      end
+    end
+
+    # object: { a => 200, b => 2 }
+    def match(object)
+      pattern.each do |key, value|
+        return false if object[key].nil?
+
+        case value
+        when Regexp
+          return false if !value.match(object[key])
+        when Hash
+          value.each do |op, value|
+            return false if !apply(op, object[key], value)
+          end
+        when object[key]
+          return false if object[key] != value
+        else
+          return false
+        end
+      end
+
+      return true
+    end
+
+  end
+
+end

data/lib/process-query-language/version.rb

@@ -0,0 +1,6 @@
+
+module ProcessQueryLanguage
+
+  Version = '0.1.0'
+
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification 
+name: process-query-language
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Tomas Carnecky
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-31 01:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: plucky
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: shoulda
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+description: 
+email: 
+- tomas.carnecky@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/process-query-language/backend/process-status.rb
+- lib/process-query-language/collection.rb
+- lib/process-query-language/matcher.rb
+- lib/process-query-language/version.rb
+- lib/process-query-language.rb
+- LICENSE
+- README.md
+has_rdoc: true
+homepage: http://github.com/wereHamster/process-query-language
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Process query language (based on plucky)
+test_files: []
+