agentx 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7bbc2d4ab57f2dfc3344a0d733bcd9620c395a51
+  data.tar.gz: a8503dd2073f8e0412fa7206ce46a44a8f85537b
+SHA512:
+  metadata.gz: a9895c44cab27796c8b73116515af66b5eee193014d9521dfb2e20255de82800b6dda4975949a5e1ef85bdd379305165083b8d400e70d8bcbf01d817ab7ae32d
+  data.tar.gz: b6d57a674c4deec1450dc41d5a57de5db7b3079ff22abb86196b5f1960a402959ab2b244b09b8c27d39235b48c46801bcab0577aec6706e1bae506b32fc7f901

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in agentx.gemspec
+gemspec

data/README

@@ -0,0 +1,31 @@
+# AgentX
+
+This is still under development.  The idea is to be a programmer-friendly tool
+for doing things on the internet.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'agentx'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install agentx
+
+## Usage
+
+TODO: Write some documentation!
+
+## Contributing
+
+1. Fork it ( https://github.com/eki/agentx/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/agentx.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'agentx/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "agentx"
+  spec.version       = AgentX::VERSION
+  spec.authors       = ["Eric K Idema"]
+  spec.email         = ["eki@vying.org"]
+  spec.summary       = %q{A tool for doing things on the Internet.}
+  spec.description   = %q{A tool for doing things on the Internet.}
+  spec.homepage      = "https://github.com/eki/agentx"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+
+  spec.add_dependency 'ethon'
+  spec.add_dependency 'http-cookie'
+  spec.add_dependency 'nokogiri'
+  spec.add_dependency 'listen'
+  spec.add_dependency 'oj'
+  spec.add_dependency 'sqlite3'
+end
+

data/bin/agentx

@@ -0,0 +1,106 @@
+#!/usr/bin/env ruby
+
+require 'agentx'
+require 'agentx/console'
+require 'fileutils'
+require 'listen'
+require 'optparse'
+
+options={}
+
+option_parser = OptionParser.new do |opts|
+  opts.banner = "Usage: agentx [OPTION] [FILE]"
+
+  opts.on('-h', '--help', 'This help message') do
+    puts opts
+    puts <<-eos
+
+If no FILE is provided, an interactive session will be started.  The 
+--interactive flag is only needed if you would like to execute a file and then 
+enter an interactive session.
+
+All file arguments should be valid Ruby.  Files will be executed in the order 
+provided at the command-line.
+
+By default a config file is located at ~/.agentx/config and should be valid
+Ruby.  This config file will be executed before any FILE arguements.  The
+default config is an empty file.
+
+    eos
+    exit
+  end
+
+  opts.on('-c', '--config [FILE]', 'Use given config file.') do |v|
+    options[:config] = v
+  end
+
+  opts.on('-i', '--interactive', 'Run an interactive console.') do
+    options[:interactive] = true
+  end
+
+  opts.on('-v', '--version', 'Print the version and exit.') do
+    puts "agentx version #{AgentX::VERSION}"
+    exit
+  end
+end
+
+option_parser.parse!
+
+console = AgentX::Console.new(options)
+console.load_config
+
+files = ARGV.map { |f| File.expand_path(f) }.select { |f| File.exists?(f) }
+
+if files.any?
+  files.each { |f| AgentX::Console.load(f) }
+else
+  options[:interactive] = true
+end
+
+if options[:interactive]
+  config_dir  = File.dirname(options[:config])
+  config_file = File.basename(options[:config])
+
+  listener = Listen.to(config_dir, only: /^#{config_file}$/) do |m,a,r|
+    console.load_config
+  end
+
+  listener.start
+
+  ARGV.clear
+
+  require 'irb'
+
+  IRB.init_config(nil)
+
+  IRB.conf[:AUTO_INDENT] = true
+  IRB.conf[:PROMPT_MODE] = :SIMPLE
+
+  IRB.conf[:SAVE_HISTORY] = 100
+  IRB.conf[:HISTORY_FILE] = "#{AgentX.root}/console.log"
+  IRB.conf[:MAIN_CONTEXT] = IRB::Irb.new.context
+
+  IRB.load_modules
+
+  require 'irb/ext/save-history'
+  require 'irb/completion'
+
+  workspace = IRB::WorkSpace.new(console)
+  irb = IRB::Irb.new(workspace)
+
+  trap("SIGINT") do
+    catch(:IRB_EXIT) do
+      irb.signal_handle
+    end
+  end
+
+  begin
+    catch(:IRB_EXIT) do
+      irb.eval_input
+    end
+  ensure
+    IRB.irb_at_exit
+    listener.stop
+  end
+end
+

data/config.example

@@ -0,0 +1,16 @@
+# AgentX Example Config
+
+# This file is plain Ruby.  Any methods you may define are available at the
+# top-level of the console and are loaded before any file you may execute.
+# Already defined:
+#
+#   load_config - (Re)loads this config file, if it's been changed.
+#   options     - The command-line options agentx was run with.
+#
+
+# Example of defining a session for quick use:
+
+# def session
+#   @session ||= AgentX::Session.new('https://www.google.com')
+# end
+

data/lib/agentx.rb

@@ -0,0 +1,53 @@
+
+require 'agentx/version'
+
+require 'digest/md5'
+require 'time'
+require 'uri'
+
+require 'ethon'
+require 'http-cookie'
+require 'nokogiri'
+require 'oj'
+require 'sqlite3'
+
+require 'agentx/history'
+require 'agentx/html'
+require 'agentx/xml'
+require 'agentx/request'
+require 'agentx/response'
+require 'agentx/cache'
+require 'agentx/session'
+
+module AgentX
+  def self.root
+    return @root if @root
+
+    @root = File.expand_path('~/.agentx')
+
+    Dir.mkdir(@root) unless Dir.exists?(@root)
+
+    @root
+  end
+
+  def self.session
+    @session ||= Session.new
+  end
+
+  def self.[](*args)
+    session[*args]
+  end
+
+  def self.logger
+    return @logger if @logger
+
+    @logger = Logger.new(File.join(root, 'request.log'))
+
+    @logger.formatter = proc do |severity, datetime, progname, msg|
+      "#{datetime} | #{msg}\n"
+    end
+
+    @logger
+  end
+end
+

data/lib/agentx/cache.rb

@@ -0,0 +1,124 @@
+
+module AgentX
+  class Cache
+    def self.store_path
+      return @store_path if @store_path
+
+      @store_path = File.join(AgentX.root, 'cache')
+
+      unless Dir.exists?(@store_path)
+        Dir.mkdir(@store_path)
+      end
+
+      @store_path
+    end
+
+    def self.path(request)
+      File.join(store_path, "#{request.cache_key}.json")
+    end
+
+    def self.db
+      @db ||= Database.new
+    end
+
+    def self.write(request, response)
+      db.write(
+        request_cache_key:       request.cache_key,
+        request_host:            request.host,
+        request_base_url:        request.base_url,
+        response_code:           response.code,
+        response_headers:        Oj.dump(response.headers.to_hash),
+        response_content_length: response.body.length,
+        response_expires_at:     response.expires_at,
+        response_body:           response.body)
+    end
+
+    def self.read(request)
+      if h = db.read(request.cache_key)
+        Response.new(
+          h['response_code'],
+          h['response_body'],
+          Oj.load(h['response_headers']))
+      end
+    end
+
+    class Database
+      attr_reader :filename
+
+      def initialize(filename=File.join(AgentX.root, 'cache.sqlite3'))
+        @filename = filename
+
+        create
+      end
+
+      def create
+        if File.exists?(filename)
+          return @db = SQLite3::Database.new(filename)
+        end
+
+        @db = SQLite3::Database.new(filename)
+
+        @db.execute(<<-SQL)
+          CREATE TABLE responses (
+            request_cache_key       STRING PRIMARY KEY,
+            request_host            STRING,
+            request_base_url        STRING,
+            response_code           INTEGER,
+            response_headers        TEXT,
+            response_content_length INTEGER,
+            response_expires_at     INTEGER,
+            response_body           BLOB)
+        SQL
+
+        @db.execute(<<-SQL)
+          CREATE INDEX responses_expires_at ON responses (response_expires_at)
+        SQL
+
+        @db.execute(<<-SQL)
+          CREATE INDEX responses_host ON responses (request_host)
+        SQL
+
+        @db
+      end
+
+      INSERT_SQL = <<-SQL
+        INSERT OR REPLACE INTO responses (
+          request_cache_key, 
+          request_host, 
+          request_base_url,
+          response_code,
+          response_headers,
+          response_content_length,
+          response_expires_at,
+          response_body) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      SQL
+
+      def write(opts={})
+        @prepared_write ||= @db.prepare(INSERT_SQL)
+
+        @prepared_write.execute(
+          opts[:request_cache_key],
+          opts[:request_host],
+          opts[:request_base_url],
+          opts[:response_code],
+          opts[:response_headers],
+          opts[:response_content_length],
+          opts[:response_expires_at].to_i,
+          opts[:response_body])
+      end
+
+      SELECT_BY_CACHE_KEY_SQL = <<-SQL
+        SELECT * FROM responses WHERE request_cache_key = ?
+      SQL
+
+      def read(cache_key)
+        @prepared_read ||= @db.prepare(SELECT_BY_CACHE_KEY_SQL)
+
+        rs = @prepared_read.execute(cache_key)
+        rs.next_hash
+      end
+
+    end
+  end
+end
+

data/lib/agentx/console.rb

@@ -0,0 +1,31 @@
+
+module AgentX
+  class Console
+    attr_reader :options
+
+    def initialize(options={})
+      @options = options
+    end
+
+    def load_config
+      unless options[:config]
+        options[:config] = "#{AgentX.root}/config"
+
+        unless File.exists?(options[:config])
+          example = 
+            File.expand_path('../../config.example', File.dirname(__FILE__))
+          FileUtils.cp(example, options[:config])
+          FileUtils.chmod(0600, options[:config])
+        end
+      end
+
+      self.class.load(options[:config])
+    end
+
+    def self.load(filename)
+      class_eval(File.read(filename))
+    end
+
+  end
+end
+

data/lib/agentx/history.rb

@@ -0,0 +1,49 @@
+
+module AgentX
+
+  class History
+    include Enumerable
+
+    def initialize
+      @entries = []
+    end
+
+    def add(request, response)
+      @entries << Entry.new(request, response)
+    end
+
+    def [](n)
+      @entries[n]
+    end
+
+    def first
+      @entries.first
+    end
+
+    def last
+      @entries.last
+    end
+
+    def length
+      @entries.length
+    end
+
+    def each(&block)
+      @entries.each(&block)
+    end
+
+    class Entry
+      attr_reader :request, :response
+
+      def initialize(request, response)
+        @request, @response = request, response
+      end
+
+      def inspect
+        [request, response].inspect
+      end
+    end
+
+  end
+end
+