beta_tools 0.0.4

data/lib/beta_tools/version.rb

@@ -0,0 +1,3 @@
+module BetaTools
+  VERSION = "0.0.4"
+end

data/lib/beta_tools.rb

@@ -0,0 +1,5 @@
+require "beta_tools/version"
+
+module BetaTools
+  # Your code goes here...
+end

data/lib/it_tools/calc.rb

@@ -0,0 +1,14 @@
+class Calculator
+  def initialize
+    @stack = []
+  end
+  def enter( value ) 
+    @stack.push value
+  end
+  def screen
+    @stack[0]
+  end
+  def add
+    @stack.push( @stack.pop + @stack.pop )
+  end
+end

data/lib/it_tools/config.ru

@@ -0,0 +1,2 @@
+require File.dirname(__FILE__) + '/solr'
+run WebApp

data/lib/it_tools/environment.rb

@@ -0,0 +1,86 @@
+require_relative 'options'
+
+class Environment
+  attr_accessor :ops
+  
+  def initialize(options = {})
+      defaults = { :jar_with_dependencies => false, :debug => true, :dry_run => false }
+      @ops = defaults.merge options
+      command_line_opts = Options.new
+      @ops = @ops.merge command_line_opts.options
+  end
+  
+  def set_options(options = {})
+    @ops = @ops.merge(options)
+  end
+
+  def deploy(env, options = {})
+    defaults = { :jar_with_dependencies => false }
+    options = defaults.merge(options)
+    @ops = @ops.merge(options)
+    puts self.inspect if ops[:debug]
+    cmd = get_deploy_command(env)
+    puts "[Command]: " + cmd if ops[:debug]
+    unless ops[:dry_run] 
+      system(cmd) 
+    end
+  end
+
+  def get_deploy_command(env,file, options = {})
+    @ops = @ops.merge(options)
+    dd = get_deploy_dir(env)
+    dh = get_hostname(env)
+    du = get_deploy_user(env)
+    mvn = Maven.new(file, @ops)
+    an = mvn.get_artifact_name(file)
+    ban = mvn.get_built_artifact_name_with_version(file)
+    puts "[Built maven artifact]: " + ban if ops[:debug]
+    sc = get_scp_command(an, du, dh, dd, ban)
+  end
+
+  def get_scp_command(src_artifact_name, login_as_who, dest_hostname,  dest_dir, dest_artifact_name = nil)
+    deploy_cmd = "rsync -avP --stats "
+    if @ops[:use_scp]
+      deploy_cmd = "scp "
+    end
+    deploy_cmd += "target/#{src_artifact_name} #{login_as_who}@#{dest_hostname}:#{dest_dir}"
+    if dest_dir
+      deploy_cmd += "/#{dest_artifact_name}"
+    end
+    return deploy_cmd;
+  end
+
+  def get_solr_base_url(env)
+    solr_base_url = {
+      'loc' => 'http://localhost:8983/solr/'
+    }
+    return solr_base_url[env]
+  end
+  def get_deploy_dir(environment)
+    user = {
+      'dev'  => '/scratch/ngsp/hrmsToCrmod',
+      'stg'  => '/u02/webapps/myhelp/custom',
+      'prod' => '/u01/app/oracle/ngsp/wls4/user_projects/domains/base_domain2/deployments'
+    }
+    return user[environment];
+  end
+  def get_deploy_user(environment)
+    f = 'ftravers'
+    user = {
+      'dev'  => f,
+      'stg'  => 'oracle',
+      'prod' => f
+    }
+    return user[environment];
+  end
+  def get_hostname(environment)
+    domain = ".us.oracle.com"
+    hosts = {
+      'loc'  => 'localhost',
+      'dev'  => 'sta00418' + domain,
+      'stg'  => 'wd1125' + domain,
+      'prod' => 'amtv1062' + domain
+    }
+    return hosts[environment]
+  end
+end # class

data/lib/it_tools/git.rb

@@ -0,0 +1,3 @@
+class Git
+
+end

data/lib/it_tools/html_publish.rb

@@ -0,0 +1,287 @@
+require "pygments"
+require "redcarpet"
+require "RedCloth"
+require 'pathname'
+require 'fileutils'
+require 'logger'
+
+require_relative 'solr'
+require_relative 'shared'
+
+module Website
+  class HTMLwithPygments < Redcarpet::Render::HTML
+    attr_accessor :ops, :log
+
+    def initialize(options = {})
+      super
+      @ops = {}
+      @ops.merge! options
+      @log = Logger.new('log.txt')
+      if level = @ops[:debug_level]
+        @log.level = level
+      else
+        @log.level = Logger::INFO
+      end
+      $toc1 = ""
+      $last_header_level = 0
+      $last_header_count = 0
+      $header = Array.new()
+      0.upto(6) { |i| $header[i] = 0 }
+    end
+
+    def block_code(code, language)
+      Pygments.highlight(code, :lexer => language)
+    end
+    def get_header_label( header_level )
+      index = header_level - 1
+      $header[index] = $header[index] + 1
+      header_level.upto($header.length - 1) { |i| $header[i] = 0 }
+      header_string = ""
+      0.upto(header_level - 1) { 
+        |i| if i == header_level - 1
+              header_string += $header[i].to_s
+              @log.debug "Header String: #{header_string}.  Header Entry: #{$header[i]}"
+            else
+              header_string += $header[i].to_s + "."
+            end
+      }
+      return header_string
+    end
+    def set_less_significant_to_zero(header_level)
+      10.times {|i| p i+1}
+    end
+    def header(text, header_level)
+      header_label = get_header_label(header_level)
+      id = text.gsub(" ", "_")
+      $toc1 += "<div class=\"toc#{header_level}\"><a href=\"##{id}\">#{header_label} - #{text}</a></div><br/>\n"
+      return "\n<h#{header_level} id=\"#{id}\">#{header_label} - #{text}</h#{header_level}>\n"
+    end
+    def postprocess(full_document)
+      temp = $toc1
+      $toc1 = ""
+      0.upto(6) { |i| $header[i] = 0 }
+      return temp + full_document
+    end
+  end
+  class MarkdownConverter
+    attr_accessor :log, :ops, :markdown, :write_dir, :debug
+    def initialize(options = {})
+      @ops = {}
+      @defaults = { :debug => false }
+      unless options.nil?
+        @defaults = @defaults.merge(options)
+      end
+      @ops = @defaults.merge(@ops)
+      @debug = @ops[:debug]
+      @log = Logger.new('log.txt')
+      if level = @ops[:debug_level]
+        @log.level = level
+      else
+        @log.level = Logger::DEBUG
+      end
+      @markdown = Redcarpet::Markdown.new(HTMLwithPygments,
+                                          :fenced_code_blocks => true,
+                                          :tables => true,
+                                          :autolink => true,
+                                          :with_toc_data => true)
+    end
+    def set_options(options = {})
+      @ops = @ops.merge(options)
+    end
+    def to_markdown(content)
+      return markdown.render(content)
+    end
+    def convert_markdown_file(dir, file)
+      @log.debug "Converting file: #{file}"
+      contents = File.open(dir + "/" + file, "r").read
+      return convert_markdown_contents(contents)
+    end
+    def convert_markdown_contents(contents)
+      contents = contents.remove_non_ascii
+      html = @markdown.render(contents.force_encoding('US-ASCII'))
+      return html
+    end
+    def get_out_file(file, write_dir)
+      basename = File.basename(file, File.extname(file))
+      @log.debug "Filename without extension: #{basename}"
+      out_file = write_dir + "/" + basename + ".html"
+      return out_file
+    end
+    def get_file_basename(file)
+      basename = File.basename(file, File.extname(file))
+    end
+
+    def write_stylesheet(read_dir,write_dir)
+      contents = File.open(read_dir + "/inputStyles.css", "rb").read
+      css = Pygments.css
+      File.open(write_dir + "/style.css", 'w') {|f| f.write(css + "\n" + contents) }
+    end
+
+    def modded_since_last_publish(src_file, write_file)
+      src_file_ts = File.stat(src_file).mtime
+      if not File.exist?(write_file)
+        @log.debug "Target file doesn't exist, will copy source to dest: #{write_file}"
+        return true
+      end
+      write_file_ts = File.stat(write_file).mtime
+      @log.debug "[SRC]:#{src_file} - #{src_file_ts}"
+      @log.debug "[DEST]:#{write_file} - #{write_file_ts}"
+
+      # should return true or false depending on modification times...
+      if write_file_ts > src_file_ts
+        @log.debug "Source file older than output file, no need to regenerate."
+        return false
+      else
+        @log.debug "Source file more recent than output file, need to regenerate."
+        return true
+      end
+    end
+
+    def modified_since_last_publish(read_dir, file, write_dir)
+      basename = File.basename(file, File.extname(file))
+      write_file = write_dir + "/" + basename + ".html"
+      src_file = read_dir + "/" + file
+      return modded_since_last_publish src_file, write_file
+    end
+
+    def get_files_to_process(doc_dir, write_dir)
+      @log.debug "Begin processing directory: " + doc_dir
+      Dir.chdir(doc_dir)
+      all_mmd_files = []
+      files_to_process = []
+      Dir.foreach(doc_dir) do |file|
+        $last_header_level = 0
+        $last_header_count = 0
+        $header = Array.new
+        0.upto(6) { |i| $header[i] = 0 }
+        convertedFile = false
+        if file == ".." or file == "."
+          @log.debug "Current entry is: #{file}, do nothing."
+          next;
+        end
+        if file.match(/^\.#/)
+          @log.debug "Do not process files that begin with .#.  Filename: #{file}"
+          next;
+        end
+        if File.stat(doc_dir + "/" + file).directory?
+          @log.debug "#{file} is a directory, skip it."
+          next;
+        end
+        if File.extname(file) == ".mmd"
+          @log.debug "Found MultiMarkdown file: #{file}"
+          if modified_since_last_publish(doc_dir, file, write_dir)
+            files_to_process.push file
+          end
+          all_mmd_files.push(file);
+          next
+        end
+        @log.debug "File: #{file} is not a known format, skipping."
+      end
+      return files_to_process, all_mmd_files
+    end
+    def process_files(files_to_process, read_from_dir, write_dirs)
+      @log.debug write_dirs.inspect
+      @log.debug "files to process are:"
+      @log.debug files_to_process.inspect
+      @log.debug "number of files to process is: " + files_to_process.length.to_s
+      files_to_process.each do |file|
+        @log.debug "Current file is:"
+        @log.debug file.inspect
+        process_file file, read_from_dir, write_dirs
+      end
+    end
+    def process_file(file, read_dir, write_dirs) 
+      @log.debug "Found file: " 
+      @log.debug read_dir.inspect
+      @log.debug file.inspect
+      indexer_dir = write_dirs[:for_indexer_dir]
+      static_site_dir = write_dirs[:for_static_files_dir]
+      indexer_file_path = get_out_file(file, indexer_dir)
+      static_file_path = get_out_file(file, static_site_dir)
+      html = convert_markdown_file(read_dir, file) 
+      write_contents_no_style(indexer_file_path, html)
+      write_contents_add_style(static_file_path,html)
+      send_to_indexer(indexer_file_path, html)
+    end
+    def send_to_indexer(file_path, html)
+      uploader = Solr::Upload.new(:solr_base_url => ops[:indexer_url])
+      file_name = get_file_basename(file_path)
+      uploader.upload_file( file_name, html, file_name )
+    end
+    def write_contents_no_style(out_file, html)
+      @log.debug "Writing file: #{out_file}"
+      File.open(out_file, 'w') {|f| f.write(html) }
+    end
+    def write_contents_add_style(out_file, html)
+      @log.debug "Writing file: #{out_file}"
+      style_info = '<head><LINK REL=StyleSheet HREF="style.css" TYPE="text/css"/></head>'
+      @log.debug "Writing html + style info to file: " + out_file
+      File.open(out_file, 'w') {|f| f.write(style_info + html) }
+    end
+    def create_index(index, write_dir)
+      index.sort! { |a,b| a.downcase <=> b.downcase }
+      file = File.open(write_dir + "/" +"index.html", 'w')
+      file.write("<html><body><ul>")
+      index.each { |filename|
+        basename = File.basename(filename, File.extname(filename))
+        file.write("<li/><a href=\"#{basename}.html\">#{basename}")
+      }
+      file.write("</ul></body></html>")
+      file.close()
+    end
+    def copy_search_files(from,to) 
+      files = [ "search.html", "search.js", "ajax-loader.gif", "help.png" ]
+      files.each do |file|
+        FileUtils.cp from + "/" + file, to
+      end
+    end
+    def copy_images_dir(read_dir, write_dirs)
+      src_dir = read_dir + "/images/"
+      if not Dir.exists? src_dir
+        @log.debug "No images directory found."
+        return
+      end
+      @log.debug "Found images directory, will copy over now."
+      write_dirs.each do |write_dir|
+        files = Dir.glob(src_dir + '/*')
+        files.each do |file|
+          write_file = write_dir + "/" + (File.basename file).to_s
+          if modded_since_last_publish(file, write_file)
+            @log.debug "Copying image: " + file
+            FileUtils.cp_r file, write_dir
+          end
+        end
+      end
+    end
+
+    def go()
+      before = Time.now
+
+      read_dir = "/home/fenton/projects/documentation"
+      write_dir = "/home/fenton/bin/website/"
+      write_dir_static = "/home/fenton/bin/website_static"
+
+      files_to_process, all_mmd_files = get_files_to_process read_dir, write_dir
+      create_index all_mmd_files, write_dir_static
+      process_files files_to_process, read_dir, :for_indexer_dir => write_dir, :for_static_files_dir => write_dir_static
+      copy_images_dir read_dir, [write_dir,write_dir_static]
+      copy_search_files read_dir, write_dir
+      write_stylesheet read_dir, write_dir
+      write_stylesheet read_dir, write_dir_static
+
+      read_dir = "/home/fenton/projects/work-doco/docs"
+      write_dir = "/home/fenton/bin/work-doco/"
+      write_dir_static = "/home/fenton/bin/work-doco_static/"
+
+      files_to_process, all_mmd_files = get_files_to_process read_dir, write_dir
+      write_dirs = {
+        :for_indexer_dir => write_dir, 
+        :for_static_files_dir => write_dir_static }
+      process_files files_to_process, read_dir, write_dirs
+      copy_images_dir read_dir, [write_dir,write_dir_static]
+      write_stylesheet read_dir, write_dir
+      write_stylesheet read_dir, write_dir_static
+      @log.debug "Elapsed time: #{Time.now - before}(s)"
+    end
+  end
+end

data/lib/it_tools/mail.rb

@@ -0,0 +1,21 @@
+require 'pony'
+
+module ItTools
+  class MailTools
+    def sendSmtpSslMail(from,to,subject,body,user, password, host, port)
+      Pony.mail(:to => to, :from => from, :subject => subject, :body => body, :via => :smtp, :smtp => {
+                  :host => host,
+                  :port => port,
+                  :user => user,
+                  :password => password,
+                  :auth => :login})
+    end
+    def sendMailToBeehive(from,to,subject,body,user, password)
+      sendSmtpSslMail(from,to,subject,body,user, password, "stbeehive.oracle.com", 465)
+    end
+  end
+end
+
+
+                
+                

data/lib/it_tools/maven.rb

@@ -0,0 +1,101 @@
+require 'xmlsimple'
+require_relative 'shared'
+require 'logger'
+
+class Maven
+  attr_accessor :ops, :pom, :re, :log
+  def initialize(xml_string, options = {})
+    defaults = { :jar_with_dependencies => false, :debug => true }
+    options = defaults.merge(options)
+    @ops = options
+    @pom = XmlSimple.xml_in xml_string
+    @re = SharedTool::RegularExpression.new
+    @log = Logger.new 'log.txt'
+    if level = @ops[:debug_level]
+      @log.level = level
+    else
+      @log.level = Logger::INFO
+    end
+    process_pom
+  end
+  def process_pom
+    @ops[:artifactId] = @pom['artifactId'][0]
+    @ops[:version] = @pom['version'][0]
+    @ops[:prev_version] = get_prev_version @ops[:version]
+  end
+
+  def build(options = {})
+    defaults = { :jar_with_dependencies => false, :environment_specific => false }
+    options = defaults.merge(options)
+    @ops = @ops.merge(options)
+    build_command = "mvn package"
+    if @ops[:jar_with_dependencies]
+      build_command = "mvn assembly:assembly"
+    end
+    if @ops[:env]
+      puts "WARNING: You are building an environment specific artifact, use caution."
+      profile = get_profile_name(@ops[:env])
+      build_command += " -P#{profile}"
+    end
+    if ops[:dry_run] 
+      puts "[would run command]: " + build_command
+    else
+      system(build_command) 
+    end
+  end
+
+  def get_profile_name(environment)
+    profile = {
+      'loc' => 'loc',
+      'dev'  => 'dev',
+      'stg'  => 'stage',
+      'prod' => 'prod'
+    }
+    return profile[environment]
+  end
+
+
+  def get_artifactId(xml_string)
+    artifactId = re.first_occurrence( xml_string, /<artifactId>(.*)<\/artifactId>/)
+  end
+
+  def get_packaging(xml_string)
+    packaging = re.first_occurrence( xml_string, /<packaging>(.*)<\/packaging>/)
+  end
+
+  def get_artifact_name(xml_string)
+    artifactId = get_artifactId(xml_string)
+    packaging = get_packaging(xml_string)
+    if ops[:jar_with_dependencies]
+      return artifactId + "-jar-with-dependencies." + packaging
+    else
+      return artifactId + "." + packaging
+    end
+  end
+
+  def has_assembly
+    plugins = @pom['build']['pluginManagement']['plugins']
+    plugins.each do |key,value|
+      p key
+    end
+  end
+  def get_built_artifact_name_with_version(xml_string)
+    version = @ops[:version]
+    prev_ver = get_prev_version(version)
+    artifactId = get_artifactId(xml_string)
+    packaging = get_packaging(xml_string)
+    # puts "Dumping class: " + self.inspect if ops[:debug]
+
+    if ops[:jar_with_dependencies]
+      return "#{artifactId}-jar-with-dependencies-#{prev_ver}.#{packaging}"
+    else
+      return "#{artifactId}-#{prev_ver}.#{packaging}"
+    end
+  end
+
+  def get_prev_version(curr_version)
+    m = /(\d+\.\d+\.)(\d+)/.match(curr_version)
+    m[1].to_s + (m[2].to_i - 1).to_s
+  end
+
+end

data/lib/it_tools/md5.rb

@@ -0,0 +1,4 @@
+# The following will print out the filename and md5 digest of all the
+# files passed to it on the command line:
+require 'digest/md5'
+digest = Digest::MD5.hexdigest(File.read(f))

data/lib/it_tools/multipart.rb

@@ -0,0 +1,78 @@
+require 'rubygems'
+require 'mime/types'
+require 'cgi'
+require "net/http"
+require "uri"
+
+module Multipart
+  VERSION = "1.0.0" unless const_defined?(:VERSION)
+  
+  # Formats a given hash as a multipart form post
+  # If a hash value responds to :string or :read messages, then it is
+  # interpreted as a file and processed accordingly; otherwise, it is assumed
+  # to be a string
+  attr_accessor :fp
+  class Post
+    # We have to pretend like we're a web browser...
+    USERAGENT = "Mozilla/5.0 (Macintosh; U; PPC Mac OS X; en-us) AppleWebKit/523.10.6 (KHTML, like Gecko) Version/3.0.4 Safari/523.10.6" unless const_defined?(:USERAGENT)
+    BOUNDARY = "0123456789ABLEWASIEREISAWELBA9876543210" unless const_defined?(:BOUNDARY)
+    CONTENT_TYPE = "multipart/form-data; boundary=#{ BOUNDARY }" unless const_defined?(:CONTENT_TYPE)
+    HEADER = { "Content-Type" => CONTENT_TYPE, "User-Agent" => USERAGENT } unless const_defined?(:HEADER)
+    def initialize
+      @fp = []
+    end
+    def add_file(filename, contents)
+      @fp.push(FileParam.new(filename, filename, contents))
+    end
+    def add_params(params = {})
+      params.each do |k, v|
+        @fp.push(StringParam.new(k, v))
+      end
+    end
+    def post(url = "http://something.com/uploads")
+      uri = URI.parse(url)
+      post_body = get_query
+      http = Net::HTTP.new(uri.host, uri.port)
+      request = Net::HTTP::Post.new(uri.request_uri)
+      request.body = post_body.join
+      request["Content-Type"] = "multipart/form-data, boundary=#{BOUNDARY}"
+      http.request(request)
+    end
+    def get_query
+      query = @fp.collect {|p| "--" + BOUNDARY + "\r\n" + p.to_multipart }.join("")  + "--" + BOUNDARY + "--"
+      return query, HEADER
+    end
+  end
+  private
+  # Formats a basic string key/value pair for inclusion with a multipart post
+  class StringParam
+    attr_accessor :k, :v
+    def initialize(k, v)
+      @k = k
+      @v = v
+    end
+    def to_multipart
+      return "Content-Disposition: form-data; name=\"#{CGI::escape(k)}\"\r\n\r\n#{v}\r\n"
+    end
+  end
+  # Formats the contents of a file or string for inclusion with a multipart
+  # form post
+  class FileParam
+    attr_accessor :k, :filename, :content
+    def initialize(k, filename, content)
+      @k = k
+      @filename = filename
+      @content = content
+    end
+    def to_multipart
+      # If we can tell the possible mime-type from the filename, use the
+      # first in the list; otherwise, use "application/octet-stream"
+      mime_type = MIME::Types.type_for(filename)[0] || MIME::Types["application/octet-stream"][0]
+      return "Content-Disposition: form-data; name=\"#{CGI::escape(k)}\"; filename=\"#{ filename }\"\r\n" +
+        "Content-Type: #{ mime_type.simplified }\r\n\r\n#{ content }\r\n"
+    end
+  end
+end
+
+
+

data/lib/it_tools/network_tools.rb

@@ -0,0 +1,72 @@
+require 'socket'  
+require 'timeout'
+require 'net/http'
+
+module NetworkTools
+  class VpnTools
+    def is_port_open?(ip, port)
+      begin
+        Timeout::timeout(1) do
+          begin
+            s = TCPSocket.new(ip, port)
+            s.close
+            return true
+          rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
+            return false
+          end
+        end
+      rescue Timeout::Error
+      end
+      return false
+    end
+
+    # * *Args*    :
+    #   - ++ ->
+    # * *Returns* :
+    #   - true if you are on the vpn or false if you are not on the vpn
+    # * *Raises* :
+    #   - ++ ->
+    def on_vpn
+      if is_port_open?("spicevan.com", 22)
+        return false
+      else
+        return true
+      end
+    end
+
+    def login_to_url2(url, port, username, password, limit = 35)
+      puts "[URL]: " + url
+      puts "[PORT]: #{port}"
+      puts "[USERNAME]: " + username
+      puts "[PASSWORD]: " + password
+
+      # You should choose a better exception.
+      raise ArgumentError, 'too many HTTP redirects' if limit == 0
+
+      uri = URI(url)
+
+      req = Net::HTTP::Get.new(uri.request_uri)
+      req.basic_auth username, password
+
+      res = Net::HTTP.start(uri.host, port, :use_ssl => uri.scheme == 'https') {|http|
+        http.request(req)
+      }
+
+      case res
+      when Net::HTTPSuccess then
+        puts "Successfully logged in." # res.body
+      when Net::HTTPRedirection then
+        location = res['location']
+        warn "redirected to #{location}"
+        login_to_url2(location, port, username, password, limit - 1)
+      else
+        response.value
+      end
+#    File.open('out.html', 'w'){|f| f.write res.body}
+      puts res.body.to_s
+    end
+
+
+  end
+end
+