web/rest-intent/add-get-intent.rb

require "rest-client"
require "optparse"

options = { 
  :rest_op => "add",
  :intent_id => 123, 
  :intent_type => "shortest_intent_type", 
  :max_switches => 4,
  :intent_op => "add"
}

parser = OptionParser.new do |opts|
  opts.banner = "Usage add-get-intent [options]"
  opts.on('-g', '--get_intents', 'get intents state') do
    options[:rest_op] = "get"
  end
  opts.on('-t', '--max_intents max_intents', 'max. number of intents') do |max_intents|
    options[:max_intents] = max_intents
  end
  opts.on('-l', '--application application_id', 'set application id') do |appl_id|
    options[:application_id] = appl_id.to_i
  end
  opts.on('-i', '--intent_id intent_id', 'global intent id') do |id|
    options[:intent_id] = id.to_i
  end
  # optional argument
  opts.on('-s', '--shortest', 'create a shortest path intent') do
    options[:intent_type] = "shortest_intent_type"
  end
  # optional argument
  opts.on('-c', '--constrained', 'create a constrained shortest path intent') do
    options[:intent_type] = "constrained_shortest_intent_type"
  end
  # optional argument
  opts.on('-r', '--random_intent', 'create minimum no. of random intents') do
    options[:random_intent] = true
  end
  opts.on('-m', '--max_switches max_switches', 'max. number of switches') do |max_switches|
    options[:max_switches] = max_switches.to_i
  end
  opts.on('-o', '--intent_op add|remove', 'an operation to post an intent') do |operation|
    options[:intent_op] = operation
  end
  opts.on('-w', '--server server', 'server to post intents') do |server|
    options[:server] = server
  end
  opts.on('-p','--port port', 'server port') do |port|
    options[:port] = port
  end
  opts.on('b', '--bulk_limit bulk_limit', 'bulk request upto this limit') do |bulk_limit|
    options[:bulk_limit] = bulk_limit
  end
  opts.on('-h', '--help', 'Display help') do
    puts opts
    exit
  end
end
parser.parse!

def rand_mac
  mac = `openssl rand -hex 6`
  mac.scan(/(..)/).join(":")
end

def rand_switch
  switch = `openssl rand -hex 5`.chomp
end

class Intent
  attr_reader :switches, :ports, :intent_id
  attr_reader :application_id, :intent_type, :intent_op
  attr_reader :random_intent, :server, :port
  attr_reader :bulk_limit

  def initialize options
    parse_options options
  end

  def post_intent 
    create_specific_intent
  end

  def get_intent
    request = RestClient.get "http://#{@server}:#{@port}/wm/onos/datagrid/get/intents/json"
    puts request
  end

  private 

  def create_specific_intent
    if @random_intent == true
      create_random_intent
    else
      create_many_intents
    end
  end

  # create as many intents as the number of switches
  def create_many_intents
    intents = []
    @switches.each do |sw|
      rest = @switches - [sw]
      intents = _create_intent sw, rest, intents
puts intents.size
      post_slice intents
    end
    post_slice intents, true
  end

  # pick a random src switch and create intents to all other switches
  def create_random_intent
    intents = []
    sw = @switches.shuffle[0]
    rest = @switches - [sw]
    intents = _create_intent sw, rest, intents
    post_slice intents, true
  end

  def post_slice intents, last=false
    @bulk_limit = @bulk_limit.to_i
    if intents.size >= @bulk_limit
      post intents.slice!(0..(@bulk_limit - 1))
    end
    if last == true
      loop do
        new_bulk_limit = intents.size > @bulk_limit ? @bulk_limit : intents.size
        post intents.slice!(0..(new_bulk_limit - 1))
        break if new_bulk_limit < @bulk_limit
      end
    end
  end

  def post intents
    json_data = intents.to_json
    response = RestClient.post "http://#{@server}:#{@port}/wm/onos/datagrid/#{intent_op}/intent/json", json_data, :content_type => :json, :accept => :json
    puts response
  end

  def parse_options options
    max_switches = options[:max_switches].to_i || 4
    @switches = (1..max_switches).to_a
    @ports = (1..(max_switches - 1)).to_a
    @intent_id = options[:intent_id]
    @intent_id ||= 1
    @application_id = options[:application_id]
    @application_id ||= 1
    @intent_type = options[:intent_type]
    @intent_op = options[:intent_op]
    @intent_op ||= "add"
    @random_intent = options[:random_intent]
    @random_intent ||= false
    @server = options[:server]
    @server ||= "127.0.0.1"
    @port = options[:port]
    @port ||= 8080
    @bulk_limit = options[:bulk_limit]
    @bulk_limit ||= 10000
  end


  def _create_intent src_switch, iterable_switches, json_intents
    network_id = 1
    iterable_switches.each_index do |sw_i|
      dst_switch = iterable_switches[sw_i]
      sw_set = @switches - [dst_switch]
      dst_port = sw_set.index(src_switch)
      dst_port = dst_port + 1
      intent = {
        :intent_id => "#{@application_id}:#{@intent_id}",
        :intent_type => @intent_type,
        :intent_op => @intent_op,
        :srcSwitch => src_switch.to_s,
        :srcPort => @ports[sw_i],
        :srcMac => "00:00:c0:a8:#{mac_format(src_switch)}",
        :dstSwitch => iterable_switches[sw_i].to_s,
        :dstPort => dst_port,
        :dstMac => "00:00:c0:a8:#{mac_format(iterable_switches[sw_i].to_i)}"
      }
puts intent.inspect
      @intent_id = @intent_id + 1
      json_intents << intent
puts
    end
    #sha256 = Digest::SHA256.new
    #sha256.update intent_hash.to_s
    #puts sha256.hexdigest
    #puts "intent hash = #{intent_hash}"
    json_intents
  end

  def mac_format number
    if number > 255
      divisor = number / 256 
      remainder = number % 256
      return sprintf("%02x:%02x",divisor ,remainder)
    end
    "00:%02x" % number
  end
end

intent = Intent.new options
if options[:rest_op] == "get"
  intent.get_intent
else
  json_data = intent.post_intent
end