enfcli 4.0.0 → 5.0.0.pre.alpha

data/lib/enfcli/commands/xcr.rb

@@ -1,5 +1,5 @@
 #
-# Copyright 2018 Xaptum,Inc
+# Copyright 2018-2020 Xaptum,Inc
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -13,56 +13,51 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-require 'enfthor'
-require 'enfapi'
+require "enfthor"
+require "enfapi"
 
 module EnfCli
-
   module Cmd
-
     class Xcr < EnfThor
       no_commands {
-        def display_endpoints eps
-          headings = ['IPV6', 'Name', 'State', 'Network', 'Remote IP']
-          rows = eps.map{ |hash|
-            [ hash[:ipv6],
-              hash[:name],
-              hash[:state],
-              hash[:state] == 'OFFLINE' ? '' : hash[:ev_asn_org],
-              hash[:state] == 'OFFLINE' ? '' : hash[:ev_remote_ip]
-            ]
+        def display_endpoints(eps)
+          headings = ["IPV6", "Name", "State", "Network", "Remote IP"]
+          rows = eps.map { |hash|
+            [hash[:ipv6],
+             hash[:name],
+             hash[:state],
+             hash[:state] == "OFFLINE" ? "" : hash[:last_event][:asn_org],
+             hash[:state] == "OFFLINE" ? "" : hash[:last_event][:remote_ip]]
           }
           render_table(headings, rows, options.file)
         end
 
-        def display_endpoint_events events
-          headings = ['Time', 'IPV6', 'Source', 'Event', 'Network', 'Remote IP']
-          rows = events.map{ |hash|
-            [ hash[:inserted_date], hash[:ipv6_text], hash[:source], hash[:type], hash[:asn_org], hash[:remote_ip]]
+        def display_endpoint_events(events)
+          headings = ["Time", "IPV6", "Source", "Event", "Network", "Remote IP"]
+          rows = events.map { |hash|
+            [hash[:inserted_date], hash[:ipv6_text], hash[:source], hash[:type], hash[:asn_org], hash[:remote_ip]]
           }
           render_table(headings, rows)
         end
 
-        def display_domains domains
-          headings = ['Name', 'Network', 'Status']
-          rows = domains.map{ |hash|
-            [ hash[:name], hash[:network], hash[:status]
-            ]
+        def display_domains(domains)
+          headings = ["Name", "Cidr", "Status"]
+          rows = domains.map { |hash|
+            [hash[:name], hash[:cidr], hash[:status]]
           }
           render_table(headings, rows)
         end
 
-        def display_networks networks
-          headings = ['Name', 'Network', 'Description', 'Status']
-          rows = networks.map{ |hash|
-            [ hash[:name], hash[:network], hash[:description], hash[:status]
-            ]
+        def display_networks(networks)
+          headings = ["Name", "Cidr", "Description", "Status"]
+          rows = networks.map { |hash|
+            [hash[:name], hash[:cidr], hash[:description], hash[:status]]
           }
           render_table(headings, rows)
         end
 
-        def display_network network
-          network_cidr = network[:network]
+        def display_network(network)
+          network_cidr = network[:cidr]
           name = network[:name] || ""
           description = network[:description] || ""
           status = network[:status] || ""
@@ -79,27 +74,27 @@ module EnfCli
           say "Modified At: #{modified_at}\n", nil, true
         end
 
-        def display_limits limits
+        def display_limits(limits)
           # Extract default limits
           default_limits = limits[:default]
           current_limits = limits[:current]
           max_limits = limits[:max]
 
           # add type to the limits hash
-          default_limits[:limit] = 'DEFAULT' if default_limits
-          max_limits[:limit] = 'MAX' if max_limits
-          current_limits[:limit] = 'CURRENT' if current_limits
+          default_limits[:limit] = "DEFAULT" if default_limits
+          max_limits[:limit] = "MAX" if max_limits
+          current_limits[:limit] = "CURRENT" if current_limits
 
           limits_array = []
           limits_array.push default_limits if default_limits
           limits_array.push current_limits if current_limits
           limits_array.push max_limits if max_limits
 
-          headings = ['Limit', 'Pkts/Sec', 'Pkts Burst Size', 'Bytes/Sec', 'Bytes Burst Size']
-          headings << 'Inherited' if limits_array.reduce(false){ |acc, hash| acc or hash.member?(:inherit)}
+          headings = ["Limit", "Pkts/Sec", "Pkts Burst Size", "Bytes/Sec", "Bytes Burst Size"]
+          headings << "Inherited" if limits_array.reduce(false) { |acc, hash| acc or hash.member?(:inherit) }
 
-          rows = limits_array.map{ |hash|
-            row = [ hash[:limit], hash[:packets_per_second], hash[:packets_burst_size], hash[:bytes_per_second], hash[:bytes_burst_size] ]
+          rows = limits_array.map { |hash|
+            row = [hash[:limit], hash[:packets_per_second], hash[:packets_burst_size], hash[:bytes_per_second], hash[:bytes_burst_size]]
             row << hash[:inherit] ? "Y" : "N" if hash.member?(:inherit)
             row
           }
@@ -109,12 +104,26 @@ module EnfCli
       }
 
       desc "list-networks", "List all virtual networks in domain"
+      method_option :domain, type: :string, default: nil, banner: "/48 CIDR",
+                             aliases: "-d"
+
       def list_networks
         try_with_rescue_in_session do
-          domain_id = EnfCli::CTX.instance.session[:domain_id]
+          # get correct domain
+          domain = EnfCli::CTX.instance.session[:domain]
+          raise EnfCli::ERROR, "User not in a valid domain!" unless domain
+
+          # check if admin
+          if EnfCli::CTX.instance.xaptum_admin?
+            raise EnfCli::ERROR, "--domain is required" unless options[:domain]
+
+            domain = options[:domain]
+          elsif options[:domain]
+            say "Warning: Ignoring command option --domain #{options[:domain]}", :yellow
+          end
 
           # Call the api
-          data = EnfApi::API.instance.list_domain_nws domain_id
+          data = EnfApi::API.instance.list_domain_nws domain
           networks = data[:data]
 
           # display table
@@ -124,12 +133,24 @@ module EnfCli
 
       desc "provision-network", "Provision a Network"
       method_option :name, :type => :array, :required => true, :banner => "NAME"
+      method_option :domain, type: :string, default: nil, banner: "/48 CIDR",
+                             aliases: "-d"
       method_option :description, :type => :array, :banner => "DESCRIPTION"
+
       def provision_network
         try_with_rescue_in_session do
-          # verify domain context is set
-          domain_id = EnfCli::CTX.instance.session[:domain_id]
-          raise EnfCli::ERROR, "User's domain not available!" if !domain_id || domain_id < 0
+          # get correct domain
+          domain = EnfCli::CTX.instance.session[:domain]
+          raise EnfCli::ERROR, "User not in a valid domain!" unless domain
+
+          # check if admin
+          if EnfCli::CTX.instance.xaptum_admin?
+            raise EnfCli::ERROR, "--domain is required" unless options[:domain]
+
+            domain = options[:domain]
+          elsif options[:domain]
+            say "Warning: Ignoring command option --domain #{options[:domain]}", :yellow
+          end
 
           # Get options
           description = ""
@@ -139,10 +160,9 @@ module EnfCli
           # Call the api
           hash = {
             :name => network_name,
-            :domain_id => domain_id,
-            :description => description
+            :description => description,
           }
-          data = EnfApi::API.instance.create_nw hash
+          data = EnfApi::API.instance.create_nw domain, hash
           networks = data[:data]
 
           # display table
@@ -153,6 +173,7 @@ module EnfCli
 
       desc "get-network", "Display network details"
       method_option :network, :type => :string, :required => true
+
       def get_network
         try_with_rescue_in_session do
           # call the api
@@ -168,6 +189,7 @@ module EnfCli
       method_option :network, :type => :string, :required => true
       method_option :name, :type => :array, :required => false, :banner => "NAME"
       method_option :description, :type => :array, :required => false, :banner => "DESCRIPTION"
+
       def update_network
         try_with_rescue_in_session do
           # Get options
@@ -188,6 +210,7 @@ module EnfCli
       end
 
       desc "list-enf-networks", "List enf /34 networks"
+
       def list_enf_networks
         try_with_rescue_in_session do
           # Call the api
@@ -195,27 +218,26 @@ module EnfCli
           networks = data[:data]
 
           # Display the data
-          headings = ['Id', 'Parent', 'Network', 'Notes', 'Status', 'Type']
-          rows = networks.map{ |hash|
-            [ hash[:id], hash[:parent], hash[:network], hash[:notes], hash[:status], hash[:type] ]
+          headings = ["Id", "Parent", "Network", "Notes", "Status", "Type"]
+          rows = networks.map { |hash|
+            [hash[:id], hash[:parent], hash[:network], hash[:notes], hash[:status], hash[:type]]
           }
           render_table(headings, rows)
-
         end
       end
 
       desc "list-domains", "List all domains"
+
       def list_domains
         try_with_rescue_in_session do
           session = EnfCli::CTX.instance.session
 
           # call api
-          data = {:data => []}
-          case session[:type]
-          when 'XAPTUM_ADMIN'
-            data = EnfApi::API.instance.list_domains
+          data = { :data => [] }
 
-          when 'DOMAIN_ADMIN'
+          if EnfCli::CTX.instance.xaptum_admin?
+            data = EnfApi::API.instance.list_domains
+          elsif EnfCli::CTX.instance.has_role?("DOMAIN_ADMIN")
             data = EnfApi::API.instance.get_domain session[:domain_id]
           end
 
@@ -229,6 +251,7 @@ module EnfCli
       method_option :name, :type => :string, :required => true
       method_option :'admin-name', :type => :array, :required => true, :banner => "ADMIN_NAME"
       method_option :'admin-email', :type => :string, :required => true, :banner => "EMAIL"
+
       def provision_domain
         try_with_rescue_in_session do
           # Get cli params
@@ -241,7 +264,7 @@ module EnfCli
             :admin_name => admin_name,
             :admin_email => admin_email,
             :name => domain_name,
-            :type => 'CUSTOMER_SOURCE'
+            :type => "CUSTOMER_SOURCE",
           }
           data = EnfApi::API.instance.create_domain hash
 
@@ -252,19 +275,20 @@ module EnfCli
       end
 
       desc "list-domain-rate-limits", "List domain rate limits"
-      method_option :network, :type => :string, :required => true, :banner => '</48 Network>'
-      method_option :filter, :type => :string, :enum => ['default', 'max']
+      method_option :domain, :type => :string, :required => true, :banner => "/48 CIDR"
+      method_option :filter, :type => :string, :enum => ["default", "max"]
+
       def list_domain_rate_limits
         try_with_rescue_in_session do
           # Call the api
-          data = EnfApi::API.instance.get_domain_rate_limits options[:network], options[:filter]
+          data = EnfApi::API.instance.get_domain_rate_limits options[:domain], options[:filter]
 
           # Get the limits
           limits = data[:data][0]
 
           # if the Api returns only the rate limits object, have to add type explicitly to display
           limits = {
-            options[:filter].to_sym => limits
+            options[:filter].to_sym => limits,
           } if options[:filter]
 
           # Display limits
@@ -273,8 +297,9 @@ module EnfCli
       end
 
       desc "list-network-rate-limits", "List network rate limits"
-      method_option :network, :type => :string, :required => true
-      method_option :filter, :type => :string, :enum => ['default', 'max']
+      method_option :network, :type => :string, :required => true, :banner => "/64 CIDR"
+      method_option :filter, :type => :string, :enum => ["default", "max"]
+
       def list_network_rate_limits
         try_with_rescue_in_session do
           # Call the api
@@ -285,7 +310,7 @@ module EnfCli
 
           # if the Api returns only the rate limits object, have to add type explicitly to display
           limits = {
-            options[:filter].to_sym => limits
+            options[:filter].to_sym => limits,
           } if options[:filter]
 
           # Display limits
@@ -295,7 +320,8 @@ module EnfCli
 
       desc "list-endpoint-rate-limits", "List endpoints rate limits"
       method_option :ipv6, :type => :string, :required => true
-      method_option :filter, :type => :string, :enum => ['current', 'max']
+      method_option :filter, :type => :string, :enum => ["current", "max"]
+
       def list_endpoint_rate_limits
         try_with_rescue_in_session do
           # Call the api
@@ -306,21 +332,21 @@ module EnfCli
 
           # if the Api returns only the rate limits object, have to add type explicitly to display
           limits = {
-            options[:filter].to_sym => limits
+            options[:filter].to_sym => limits,
           } if options[:filter]
 
-
           # Display limits
           display_limits limits
         end
       end
 
       desc "activate-domain", "Activate a customer's /48 domain"
-      method_option :network, :type => :string, :required => true
+      method_option :domain, :type => :string, :required => true, banner: "/48 CIDR"
+
       def activate_domain
         try_with_rescue_in_session do
           # Call api
-          data = EnfApi::API.instance.update_domain_status options[:network], {:status => "ACTIVE"}
+          data = EnfApi::API.instance.update_domain_status options[:domain], { :status => "ACTIVE" }
           domains = data[:data]
 
           # Display the data
@@ -330,11 +356,12 @@ module EnfCli
       end
 
       desc "deactivate-domain", "Deactivate a customer's /48 domain"
-      method_option :network, :type => :string, :required => true
+      method_option :domain, :type => :string, :required => true, banner: "/48 CIDR"
+
       def deactivate_domain
         try_with_rescue_in_session do
           # Call api
-          data = EnfApi::API.instance.update_domain_status options[:network], {:status => "READY"}
+          data = EnfApi::API.instance.update_domain_status options[:domain], { :status => "READY" }
           domains = data[:data]
 
           # Display the data
@@ -344,27 +371,28 @@ module EnfCli
       end
 
       desc "set-domain-rate-limits", "Update a customer /48 domain's endpoint rate limits"
-      method_option :network, :type => :string, :required => true
-      method_option :limit, :type => :string, :enum => ['default', 'max'], :required => true
-      method_option :'packets-per-second', :type => :numeric, :required => true
-      method_option :'packets-burst-size', :type => :numeric, :required => true
-      method_option :'bytes-per-second', :type => :numeric, :required => true
-      method_option :'bytes-burst-size', :type => :numeric, :required => true
+      method_option :domain, :type => :string, :required => true, banner: "/48 CIDR"
+      method_option :limit, :type => :string, :enum => ["default", "max"], :required => true
+      method_option :'packets-per-second', :type => :numeric, :required => true, aliases: "-p"
+      method_option :'packets-burst-size', :type => :numeric, :required => true, aliases: "-P"
+      method_option :'bytes-per-second', :type => :numeric, :required => true, aliases: "-b"
+      method_option :'bytes-burst-size', :type => :numeric, :required => true, aliases: "-B"
+
       def set_domain_rate_limits
         try_with_rescue_in_session do
           # Call api
           hash = {
-            :packets_per_second => options['packets-per-second'],
-            :packets_burst_size => options['packets-burst-size'],
-            :bytes_per_second => options['bytes-per-second'],
-            :bytes_burst_size => options['bytes-burst-size']
+            :packets_per_second => options["packets-per-second"],
+            :packets_burst_size => options["packets-burst-size"],
+            :bytes_per_second => options["bytes-per-second"],
+            :bytes_burst_size => options["bytes-burst-size"],
           }
-          data = EnfApi::API.instance.update_domain_rate_limits options[:network], options[:limit], hash
+          data = EnfApi::API.instance.update_domain_rate_limits options[:domain], options[:limit], hash
           limits = data[:data][0]
 
           # The Api returns only the rate limits object. Have to add type explicitly to display
           limits_hash = {
-            options[:limit].to_sym => limits
+            options[:limit].to_sym => limits,
           }
           display_limits limits_hash
         end
@@ -372,26 +400,27 @@ module EnfCli
 
       desc "set-network-rate-limits", "Update a customer /64 network's endpoint rate limits"
       method_option :network, :type => :string, :required => true
-      method_option :limit, :type => :string, :enum => ['default', 'max'], :required => true
-      method_option :'packets-per-second', :type => :numeric, :required => true
-      method_option :'packets-burst-size', :type => :numeric, :required => true
-      method_option :'bytes-per-second', :type => :numeric, :required => true
-      method_option :'bytes-burst-size', :type => :numeric, :required => true
+      method_option :limit, :type => :string, :enum => ["default", "max"], :required => true
+      method_option :'packets-per-second', :type => :numeric, :required => true, aliases: "-p"
+      method_option :'packets-burst-size', :type => :numeric, :required => true, aliases: "-P"
+      method_option :'bytes-per-second', :type => :numeric, :required => true, aliases: "-b"
+      method_option :'bytes-burst-size', :type => :numeric, :required => true, aliases: "-B"
+
       def set_network_rate_limits
         try_with_rescue_in_session do
           # Call api
           hash = {
-            :packets_per_second => options['packets-per-second'],
-            :packets_burst_size => options['packets-burst-size'],
-            :bytes_per_second => options['bytes-per-second'],
-            :bytes_burst_size => options['bytes-burst-size']
+            :packets_per_second => options["packets-per-second"],
+            :packets_burst_size => options["packets-burst-size"],
+            :bytes_per_second => options["bytes-per-second"],
+            :bytes_burst_size => options["bytes-burst-size"],
           }
           data = EnfApi::API.instance.update_network_rate_limits options[:network], options[:limit], hash
           limits = data[:data][0]
 
           # The Api returns only the rate limits object. Have to add type explicitly to display
           limits_hash = {
-            options[:limit].to_sym => limits
+            options[:limit].to_sym => limits,
           }
           display_limits limits_hash
         end
@@ -399,19 +428,20 @@ module EnfCli
 
       desc "reset-network-rate-limits", "Reset customer /64 network's endpoint rate limits to domains rate limits"
       method_option :network, :type => :string, :required => true
-      method_option :limit, :type => :string, :enum => ['default', 'max'], :required => true
+      method_option :limit, :type => :string, :enum => ["default", "max"], :required => true
+
       def reset_network_rate_limits
         try_with_rescue_in_session do
           # Call api
           hash = {
-            :inherit => true
+            :inherit => true,
           }
           data = EnfApi::API.instance.update_network_rate_limits options[:network], options[:limit], hash
           limits = data[:data][0]
 
           # The Api returns only the rate limits object. Have to add type explicitly to display
           limits_hash = {
-            options[:limit].to_sym => limits
+            options[:limit].to_sym => limits,
           }
           display_limits limits_hash
         end
@@ -419,26 +449,27 @@ module EnfCli
 
       desc "set-endpoint-rate-limits", "Update an ipv6 endpoint rate limits"
       method_option :ipv6, :type => :string, :required => true
-      method_option :limit, :type => :string, :enum => ['current', 'max'], :required => true
-      method_option :'packets-per-second', :type => :numeric, :required => true
-      method_option :'packets-burst-size', :type => :numeric, :required => true
-      method_option :'bytes-per-second', :type => :numeric, :required => true
-      method_option :'bytes-burst-size', :type => :numeric, :required => true
+      method_option :limit, :type => :string, :enum => ["current", "max"], :required => true
+      method_option :'packets-per-second', :type => :numeric, :required => true, aliases: "-p"
+      method_option :'packets-burst-size', :type => :numeric, :required => true, aliases: "-P"
+      method_option :'bytes-per-second', :type => :numeric, :required => true, aliases: "-b"
+      method_option :'bytes-burst-size', :type => :numeric, :required => true, aliases: "-B"
+
       def set_endpoint_rate_limits
         try_with_rescue_in_session do
           # Call api
           hash = {
-            :packets_per_second => options['packets-per-second'],
-            :packets_burst_size => options['packets-burst-size'],
-            :bytes_per_second => options['bytes-per-second'],
-            :bytes_burst_size => options['bytes-burst-size']
+            :packets_per_second => options["packets-per-second"],
+            :packets_burst_size => options["packets-burst-size"],
+            :bytes_per_second => options["bytes-per-second"],
+            :bytes_burst_size => options["bytes-burst-size"],
           }
           data = EnfApi::API.instance.update_ep_rate_limits options[:ipv6], options[:limit], hash
           limits = data[:data][0]
 
           # The Api returns only the rate limits object. Have to add type explicitly to display
           limits_hash = {
-            options[:limit].to_sym => limits
+            options[:limit].to_sym => limits,
           }
           display_limits limits_hash
         end
@@ -446,35 +477,33 @@ module EnfCli
 
       desc "reset-endpoint-rate-limits", "Reset an ipv6 endpoint rate limits to network's rate limits"
       method_option :ipv6, :type => :string, :required => true
-      method_option :limit, :type => :string, :enum => ['current', 'max'], :required => true
+      method_option :limit, :type => :string, :enum => ["current", "max"], :required => true
+
       def reset_endpoint_rate_limits
         try_with_rescue_in_session do
           # Call api
           hash = {
-            :inherit => true
+            :inherit => true,
           }
           data = EnfApi::API.instance.update_ep_rate_limits options[:ipv6], options[:limit], hash
           limits = data[:data][0]
 
           # The Api returns only the rate limits object. Have to add type explicitly to display
           limits_hash = {
-            options[:limit].to_sym => limits
+            options[:limit].to_sym => limits,
           }
           display_limits limits_hash
         end
       end
 
       desc "list-endpoints", "List all connections in a network"
-      method_option :network, :type => :string, :required => true
+      method_option :network, :type => :string, :required => true, banner: "/48 CIDR"
       method_option :file, :type => :string, :aliases => "-f"
+
       def list_endpoints
         try_with_rescue_in_session do
-          # verify domain context is set
-          domain_id = EnfCli::CTX.instance.session[:domain_id]
-          raise EnfCli::ERROR, "User's domain not available!" if !domain_id || domain_id < 0
-
           # call api
-          data = EnfApi::API.instance.list_nw_connections domain_id, options.network, options.file
+          data = EnfApi::API.instance.list_nw_connections options.network
           cxns = data[:data]
 
           # display table
@@ -484,6 +513,7 @@ module EnfCli
 
       desc "list-endpoint-events", "List connect/disconnect events for an ipv6 endpoint"
       method_option :ipv6, :type => :string, :required => true
+
       def list_endpoint_events
         try_with_rescue_in_session do
           # call the api
@@ -492,12 +522,12 @@ module EnfCli
 
           # display data
           display_endpoint_events events
-
         end
       end
 
       desc "list-network-events", "List connect/disconnect events of ipv6 endpoints in a network"
       method_option :network, :type => :string, :required => true
+
       def list_network_events
         try_with_rescue_in_session do
           # call the api
@@ -511,6 +541,7 @@ module EnfCli
 
       desc "get-endpoint", "Display an ipv6 endpoint's information"
       method_option :ipv6, :type => :string, :required => true
+
       def get_endpoint
         try_with_rescue_in_session do
           # call the api
@@ -525,6 +556,7 @@ module EnfCli
       desc "update-endpoint", "Update an ipv6 endpoint's name"
       method_option :ipv6, :type => :string, :required => true
       method_option :name, :type => :array, :required => true, :banner => "NAME"
+
       def update_endpoint
         try_with_rescue_in_session do
           # Call the api
@@ -537,17 +569,17 @@ module EnfCli
       end
 
       desc "activate-enf-network", "Active a /34 enf network"
-      method_option :network, :type => :string, :required => true
+      method_option :cidr, :type => :string, :required => true
+
       def activate_enfnw
         try_with_rescue_in_session do
           # Call the api
-          EnfApi::API.instance.activate_enfnw options.network
+          EnfApi::API.instance.activate_enfnw options.cidr
 
           # Print success
-          say "Activated Enf Network #{options.network}!", :green
+          say "Activated Enf Network #{options.cidr}!", :green
         end
       end
-
     end # class
   end # module Cmd
 end # module EnfCli