mu 5.7.2.3

data/bin/mu

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+lib = File.expand_path(File.dirname(__FILE__) + '/../lib')
+$LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
+
+require 'mu'
+
+argv = ARGV.dup
+ARGV.clear
+cmd = argv.shift.strip rescue 'help'
+Mu.run cmd, argv

data/lib/mu.rb

@@ -0,0 +1,65 @@
+require 'rubygems'
+require 'hexy'
+require 'json/pure'
+require 'logger'
+require 'net/https'
+require 'nokogiri'
+require 'restclient'
+require 'uri'
+
+# Command-line tools and applications for using the Mu Dynamics REST Api's
+class Mu
+    require 'mu/helper'
+    @version = "5.7.2"
+    Version = @version.freeze
+    $log = Logger.new(STDOUT)
+    $cookie = nil # http_helper
+           
+    extend Mu::Helper
+    
+    def self.run cmd, argv
+        $log.datetime_format = "%Y-%m-%d %H:%M:%S"
+        $log.level = Logger::INFO
+        $log.formatter = proc { |severity, datetime, progname, msg|
+         "[#{datetime} #{severity}]: #{msg}\n"
+         }
+
+        check_version
+
+        kname, mname = cmd.split(':', 2)
+        klass = Mu::Command.const_get kname.capitalize rescue nil
+        mname ||= 'default'
+        mname = "cmd_#{mname}".to_sym
+        if klass and klass < Mu::Command and klass.method_defined? mname
+            command = klass.new
+            begin
+                command.send mname, argv
+            rescue => e
+                error e.message.chomp('.')
+            end
+        else
+            error "Unknown command #{cmd}"
+        end        
+    end
+
+    def self.check_version
+      begin
+        api = Mu::System.new(ENV['MU_IP'], ENV['MU_ADMIN_USER'], ENV['MU_ADMIN_PASS'])
+        resp = Nokogiri::XML(api.status)
+        version_string = resp.xpath("//versions/platform")[0].content
+        version = version_string[0...version_string.rindex(".")]
+        if @version > version
+          puts "Warning. Version mismatch. Mu Gem version (#{@version}) is higher than Mu Platform version (#{version})"
+        end
+      rescue => e
+        puts "#{e}. Check Mu env settings: $MU_IP (#{ENV['MU_IP']}), $MU_ADMIN_USER (#{ENV['MU_ADMIN_USER']}), $MU_ADMIN_PASS (#{ENV['MU_ADMIN_PASS']}) "
+      end
+
+    end
+end
+
+require 'mu/client'
+require 'mu/curl/error'
+require 'mu/curl/verify'
+require 'mu/command'
+require 'mu/http_helper'

data/lib/mu/api/ddt.rb

@@ -0,0 +1,233 @@
+class Mu
+class Ddt
+  include Helper
+  
+  attr_accessor :host, :docroot, :username, :password, :session_id
+
+  def initialize(host=ENV['MU_IP'], username=ENV['MU_ADMIN_USER'], password=ENV['MU_ADMIN_PASS'])
+    @host = host
+    @username  = username
+    @password  = password
+    @docroot = "/api/v5/ddt/"
+    @session_id = nil
+    @http = HttpHelper.new(@host, @username, @password, @docroot)
+    msg "Created Ddt Api object to :#{@host}", Logger::DEBUG
+  end
+
+  # verifies the loaded scenario
+  def run
+    response = @http.post("session/test/run")
+    msg response, Logger::DEBUG
+    return response
+  end
+
+  # sets and executes test suite
+  #   * uuid = the uuid of a testset loaded on the Mu
+  def run_testset(uuid)
+    response = @http.post("session/test/runSuite/#{uuid}")
+    msg response, Logger::DEBUG
+    return response
+  end
+
+  # must be called first to establish a new Studio Verify session
+  def new_session
+    reply = @http.post("newSession") # with no args
+    response = reply["response"]
+    msg response, Logger::DEBUG
+    @session_id = response["sessionId"]
+    msg @session_id, Logger::DEBUG
+    return @session_id  
+  end
+
+  # closes the existing Studio Verify session
+  def close_session
+    response = @http.get("session/closeSession")
+    msg response, Logger::DEBUG
+    return response
+  end
+
+  # returns array of session_ids
+  def get_sessions
+    all_sessions = Array.new
+    response = @http.get("")  # with no args
+    sessions = response["sessions"]
+    if !sessions["session"].nil?
+      num = sessions["session"].size
+      if num > 1
+        sessions["session"].each do | s |
+          all_sessions << s["id"]
+        end
+      else # special case if there is only one (there is no array)
+        all_sessions << sessions["session"]["id"]
+      end
+      return all_sessions
+    end
+    return nil
+  end
+
+  # closes all Studio Verify sessions
+  def close_all_sessions
+    response = @http.post("closeAllSessions")
+    msg response, Logger::DEBUG
+    return response
+  end
+
+  # returns the session id's of all existing Studio Verify sessions
+  def get_all_sessions
+    response = @http.get("getAllSessions")
+    msg response, Logger::DEBUG
+    return response
+  end
+
+  # sets up a test for run
+  def setup_test
+    response = @http.post("session/setupTest")
+    msg response, Logger::DEBUG
+    return response
+  end
+
+  # tears down a test
+  def teardown_test
+    response = @http.post("session/test/tearDownTest")
+    msg response, Logger::DEBUG
+    return response
+  end
+
+  # loads a scenario
+  #   * the uuid of a scenario present on the Mu
+  def load_scenario(uuid)
+    response = @http.post("session/loadScenario/#{uuid}")
+    msg response, Logger::DEBUG
+    return response
+  end
+
+  # returns the hosts in the loaded scenario
+  def get_hosts
+    response = @http.get("session/scenario/hosts")
+    msg response, Logger::DEBUG
+    return response
+  end
+
+  # sets the hosts in the loaded scenario
+  #   * roles = an array of the host roles defined in the scenario
+  #   * names = an array of host names to be mapped to the roles
+  #   * type = network layer type (v4, v6 or l2) matching the defined hosts
+  def set_hosts(roles=[], names=[], type="v4")
+    responses = Array.new
+    hosts = roles.length.to_i
+    hosts.times do | i |
+       response = @http.post("session/scenario/hosts/#{roles[i]}/#{names[i]}/#{type}")
+       responses << response
+    end
+    msg responses, Logger::DEBUG
+    return responses
+  end
+
+  # returns the channel elements of the loaded scenario
+  def get_channels
+    response = @http.get("session/scenario/channels")
+    msg response, Logger::DEBUG
+    return response
+  end
+
+  # sets the channel elements of the loaded scenario
+  #  * roles = an array of the roles defined for the channels in the scenario ('channel')
+  #  * names = an array of host names to be mapped to the roles
+  def set_channels(roles=[], names=[])
+    responses = Array.new
+    roles.length.times do | i |
+        response = @http.post("session/scenario/channels/#{roles[i]}/#{names[i]}")
+        responses << response
+    end
+    msg responses, Logger::DEBUG
+    return responses
+  end
+
+  # returns the options from the loaded scenario
+  def get_options
+    response = @http.get("session/scenario/options")
+    msg response, Logger::DEBUG
+    return response
+  end
+
+  # sets the options for the loaded scenario
+  #  * an array of option names
+  #  * an array of option values
+  def set_options(names=[], values=[])
+    responses = Array.new
+    names.length.times do | i |
+       response = @http.post("session/scenario/options/#{names[i]}/#{values[i]}")
+       responses << response
+    end
+    msg responses, Logger::DEBUG
+    return responses
+  end
+
+  # collects results until the test is done or the timeout expires
+  #   * timeout = time in seconds to wait for the test to complete
+  def collect_results(timeout=120)
+    wait_until_done(timeout)
+    results = get_testset_results
+    return results
+  end
+
+  # waits until the test is done or the timeout expires
+  #   * timeout = the time in seconds to wait for the test to complete
+  def wait_until_done(timeout=120)
+    finished = false
+    interval = timeout / 10
+    10.times do
+      begin
+        response = get_testset_status
+        #msg "wait_until_done, response = #{response}", Logger::DEBUG
+        if !response.nil?
+          if response.to_s.include?("Done")
+            finished = true
+            return finished
+          end
+        end
+      rescue Exception => e
+        puts e, Logger::DEBUG # status may not be ready right away. may return a 500
+      end
+      sleep interval
+    end
+    return finished
+  end
+
+  # returns the status of a running test set
+  def get_testset_status
+    response = @http.get("session/test/runSuite/status")
+    msg response, Logger::DEBUG
+    return response
+  end
+
+  # returns the results of a running test set. can be called repeatedly.
+  # the test is done when the results include the 'END' keyword
+  def get_testset_results
+    response = @http.get("session/test/runSuite/results")
+    msg response, Logger::DEBUG
+    return response
+  end
+
+  # exports a testset to a csv file
+  #   * uuid = the uuid of the testset to export
+  def csv_export(uuid=@testset)
+    response = @http.post("session/test/export/csv/#{uuid}")
+    msg response, Logger::DEBUG
+    return response
+  end
+
+
+  # imports a csv file to the Mu
+  #  * filepath = the path to the csv file
+  def csv_import(filepath)
+    return "new_session required" if $cookie.nil? or $cookie["testSessionId"].nil?
+    testSessionId = $cookie["testSessionId"]
+    response = @http.post_form("session/test/import/csv?testSessionId=#{testSessionId}", filepath)
+    msg response, Logger::DEBUG
+    return response
+  end
+ 
+end
+end
+

data/lib/mu/api/homepage.rb

@@ -0,0 +1,54 @@
+class Mu
+class Homepage
+  include Helper
+  
+  attr_accessor :host, :docroot, :cookie, :username, :password, :session_id, :results, :posted_uuid, :testsuite, :results, :failed, :errors
+  
+  def initialize(host=ENV['MU_IP'], username=ENV['MU_ADMIN_USER'], password=ENV['MU_ADMIN_PASS'])
+    @host = host
+    @username  = username
+    @password  = password
+    @docroot = "/api/v5/homepage/"
+    @cookie = ""
+    @response = nil
+    @http = HttpHelper.new(@host, @username, @password, @docroot)
+    msg "Created Homepage object to :#{@host}", Logger::DEBUG
+  end
+
+  # returns all homepage elements
+  def all
+    response = @http.get("all/")
+    msg response, Logger::DEBUG
+    return response
+  end
+
+  # returns recent homepage activity
+  def recent
+    response = @http.get("recent/")
+    msg response, Logger::DEBUG
+    return response
+  end
+
+  # returns homepage status
+  def status
+    response = @http.get("status/")
+    msg response, Logger::DEBUG
+    return response
+  end
+
+  # returns the latest test
+  def latest_test
+    response = @http.get("test/latest/")
+    msg response, Logger::DEBUG
+    return response
+  end
+
+  # returns queued tests
+  def queue_test
+    response = @http.get("test/queue/")
+    msg response, Logger::DEBUG
+    return response
+  end
+
+end 
+end # Mu

data/lib/mu/api/muapi.rb

@@ -0,0 +1,231 @@
+class Mu
+class Muapi
+  include Helper
+  
+  attr_accessor :host, :docroot, :posted_uuid, :run_uuid, :job_id, :username, :password, :params, :expected_error
+
+  def initialize(host=ENV['MU_IP'], username=ENV['MU_ADMIN_USER'], password=ENV['MU_ADMIN_PASS'])
+    @host = host
+    @username  = username
+    @password  = password
+    @docroot = "/api/v3/"
+    @params = nil
+    @expected_error = nil
+    @http = HttpHelper.new(@host, @username, @password, @docroot)
+    msg "Created Mu Api object to :#{@host}", Logger::DEBUG
+  end
+
+  # lists the statuses of tests
+  #  * status = the status type, such as 'running' or 'failed'
+  def list_by_status(status="")
+    uuid_list = Array.new()
+    if !status.empty?
+      doc = @http.get_xml("analysis/list?status=#{status}")
+    else
+      doc = @http.get_xml("analysis/list")
+    end
+    unless doc.xpath("//analysis").empty?
+      doc.xpath('//analysis').each { |e| uuid_list << e.attribute('uuid') }
+    end
+    return uuid_list
+  end
+
+  # returns the status of a test
+  #  * uuid = the uuid of the test
+  def status(uuid=@run_uuid)
+    doc = @http.get_xml("analysis/status?uuid=#{uuid}")
+    return nil if doc.nil?
+    unless doc.xpath("//analysis").empty?
+      status = doc.xpath("//status")[0].text
+      return status
+    end
+    return doc
+  end
+
+  # starts a test
+  #  * uuid = the uuid of the test
+  def run(uuid, rename="")
+    req = "analysis/run?uuid=#{uuid}"
+    unless rename.empty?
+      req = "#{req}&rename=#{rename}"
+    end
+    doc = @http.get_xml(req)
+    unless doc.xpath("//analysis").empty?
+      @run_uuid = doc.xpath("//analysis")[0].attribute('uuid')
+      return @run_uuid
+    end
+    return @run_uuid
+  end
+
+  # stops a running test
+  #  * uuid = the uuid of the test
+  def stop(uuid=@run_uuid)
+    doc = @http.get_xml("analysis/stop?uuid=#{uuid}")
+    unless doc.xpath("//analysis").empty?
+      status = doc.xpath("//analysis")[0].attribute('status')
+      return status
+    end
+    return false
+  end
+
+  # pauses a running test
+  #  * uuid = the uuid of the test
+  def pause(uuid=@run_uuid)
+    doc = @http.get_xml("analysis/pause?uuid=#{uuid}")
+    unless doc.xpath("//analysis").empty?
+      status = doc.xpath("//analysis")[0].attribute('status')
+      return status
+    end
+    return false
+  end
+
+  # resumes a suspended test
+  #  * uuid = the uuid of the test
+  def resume(uuid=@run_uuid)
+    doc = @http.get_xml("analysis/resume?uuid=#{uuid}")
+    unless doc.xpath("//analysis").empty?
+      status = doc.xpath("//analysis")[0].attribute('status')
+      return status
+    end
+    return false
+  end
+
+  # deletes the specified test
+  #  * uuid = the uuid of the test
+  def delete(uuid=@run_uuid)
+    doc = @http.get_xml("analysis/delete?uuid=#{uuid}")
+    unless doc.xpath("//analysis").empty?
+      status = doc.xpath("//analysis")[0].attribute('status')
+      return status
+    end
+    return true
+  end
+
+  # returns a list of faults from the specified test
+  #  * uuid = the uuid of the test
+  def get_faults(uuid=@run_uuid)
+    doc = @http.get_xml("templates/export?uuid=#{uuid}")
+    unless doc.xpath("//analysis").empty?
+      faults = get_xml("analysis/getFaultList?uuid=#{uuid}",true)
+      return faults
+    end
+    return "error: no analysis with uuid: #{uuid} found"
+  end
+
+  # returns the name of an test
+  #   * uuid = the uuid of the test
+  def get_name(uuid=@run_uuid)
+    doc = @http.get_xml("templates/export?uuid=#{uuid}")
+    unless doc.xpath("//analysis").empty?
+      return doc.xpath("//analysis")[0].attribute('name')
+    end
+    return
+  end
+
+  # lists the templates on the Mu system using the template type and template name:
+  #  * type = the template type, such as 'scenario' or 'monitor'
+  def list(type)
+    names = Array.new
+    doc = @http.get_xml("templates/list?type=#{type}")
+    doc.xpath("//templates/*").each {|a| names << a.attribute('name') }
+    return names
+  end
+
+  # lists the types of templates on the Mu system
+  def types
+    doc = @http.get("templates/types?")
+    return doc
+  end
+
+  # exports a template from the Mu system using the template type and template name
+  #  * name = the template name
+  def export_by_type_and_name(type, name)
+    return @http.get_xml("templates/export?type=#{type}&name=#{name}")
+  end
+
+  # exports a template from the Mu system using the template uuid
+  #  * uuid = the template uuid
+  def export_by_uuid(uuid)
+    return @http.get_xml("templates/export?uuid=#{uuid}")
+  end
+
+  # performs archive operations
+  #   * command=run to create a test archive
+  #   * command=status to view the status of a test archive job
+  #   * command=get to download a test archive job
+  #   * uuid = the uuid of the test
+  def archive(command="run", id=@run_uuid)
+    case command
+    when 'run'
+      request_string = "archive/run?uuid=#{id}"
+      request_string += @params unless @params.nil?
+      doc = @http.get_xml(request_string)
+      unless doc.xpath("//job").empty?
+        @job_id = doc.xpath("//job")[0].attribute('id')
+        msg "job_id = #{@job_id}"
+        return @job_id
+      end
+      return doc
+    when 'status'
+      doc = @http.get("archive/status?jobId=#{id}")
+      return doc
+    when 'get'
+      file_size = @http.download_file("archive/get?jobId=#{id}","#{id}.zip")
+      return "#{id}.zip file size = #{file_size}"
+    end
+    return false
+  end
+
+  # performs backup operations
+  #  * command=run to create a system backup file.
+  #  * command=status to view the status of a backup job. If no backup job is running, gets the date of the most recent backup.
+  #  * command=get to retrieve the backup file
+  #  * name = backup file name
+  def backup(command="run", name="")
+    case command
+    when 'run'
+      doc = @http.get_xml("backup/run")
+      unless doc.xpath("//job").empty?
+        @job_id = doc.xpath("//job")[0].attribute('id')
+        msg "job_id = #{@job_id}"
+        return @job_id
+      end
+      return doc
+    when 'status'
+      doc = @http.get("backup/status")
+      return doc
+    when 'get'
+      file_size = @http.download_file("backup/get","#{name}.dat")
+      return "#{name}.dat file size = #{file_size}"
+    end
+    return false
+  end
+
+  # packet capture operations
+  #   * command=run to start capturing packets on the specified Mu appliance port
+  #   * command=status tp view the status of packet capture activity
+  #   * command=get to download the pcap file generated during packet capture
+  #   * port = the Mu appliance port
+  #   * id = job_id for status and get commands
+  def capture(command='run', port='a1', id=@job_id)
+    case command
+    when 'run'
+      doc = @http.get_xml("capture/run?port=#{port}")
+      unless doc.xpath("//job").empty?
+        @job_id = doc.xpath("//job")[0].attribute('id')
+        msg "job_id = #{@job_id}"
+        return @job_id
+      end
+      return doc
+    when 'status'
+      doc = @http.get("capture/status?jobId=#{id}")
+      return doc
+    when 'get'
+      file_size = @http.download_file("capture/get?jobId=#{id}","#{id}.pcap")
+      return "#{id}.pcap file size = #{file_size}"
+    end
+    return false
+  end
+
+end 
+end # Mu