enfcli 3.3.4 → 3.4.0.pre.alpha

data/lib/enfcli/commands/captive.rb

@@ -0,0 +1,485 @@
+# frozen_string_literal: true
+
+#
+# Copyright 2018-2019 Xaptum,Inc
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+require 'enfthor'
+require 'enfapi'
+require 'json'
+
+module EnfCli
+  module Cmd
+    class Captive < EnfThor
+      desc 'list-wifi-configurations',
+           'List wifi configuration information for all or the matching records.'
+      method_option :name, default: nil, type: :string, banner: 'NAME',
+                           desc: 'where NAME will match the user-given name.'
+      method_option :domain, default: nil, type: :string, banner: 'DOMAIN',
+                             aliases: '-d'
+      method_option :ssid, default: nil, type: :string, banner: 'SSID'
+      def list_wifi_configurations
+        try_with_rescue_in_session do
+          ## TODO: V1 is only listing all of the wifi configurations, it is not
+          ## using the options - add the queries based on the options given.
+          wifi_configs = EnfApi::Captive.instance.list_wifi_configurations
+
+          if wifi_configs.class == Array
+            # display the data
+            display_wifi_configs wifi_configs
+          else
+            say 'No WiFi configurations found.'
+          end
+        end
+      end
+
+      desc 'create-wifi-configuration', 'Create a new wifi configuration.'
+      method_option :'wifi-config-file', type: :array, required: true,
+                                         banner: '<file>',
+                                         desc: '<file> is JSON file with parameters required for configuring the router card.'
+      def create_wifi_configuration
+        try_with_rescue_in_session do
+          json_file_name = options[:'wifi-config-file'].join(' ')
+
+          # read in the entire file - yes it is slurping the file, but it should
+          # never be bigger than a few KB.
+          content = File.read json_file_name
+          json_hash = JSON.parse(content)
+
+          resp_data = EnfApi::Captive.instance.create_wifi_configuration json_hash
+
+          # display the data
+          display_wifi_detail resp_data
+        end
+      end
+
+      desc 'get-wifi-configuration',
+           'Get details of the specified wifi configuration. Exactly one of: ' \
+           '--wifi-id, --profile-id, --device-id, or --wifi-name must be ' \
+           'specified.'
+      method_option :'wifi-id', defaut: nil, type: :string, banner: 'WIFI-ID',
+                                desc: 'WIFI-ID is the UUID of the wifi record'
+      method_option :version, defaut: nil, type: :string, banner: 'VERSION',
+                              desc: 'Optionally used with --wifi-id'
+      method_option :'profile-id', defaut: nil, type: :string, banner: 'PROFILE-ID',
+                                   desc: 'PROFILE-ID is the UUID of the profile.'
+      method_option :'device-id', defaut: nil, type: :string, banner: 'DEVICE-ID',
+                                  desc: 'DEVICE-ID is the UUID of the device.'
+      method_option :'wifi-name', defaut: nil, type: :string, banner: 'WIFI-NAME',
+                                  desc: 'Result matches any wifi configuration that contains the substring WIFI-NAME'
+      def get_wifi_configuration
+        try_with_rescue_in_session do
+          ## TODO - Currently, this only handles wifi-id, add the others to v2
+
+          wifi_id = options[:'wifi-id']
+          profile_id = options[:'profile-id']
+          device_id = options[:'device-id']
+          wifi_name = options[:'wifi-name']
+          version = options[:version]
+
+          num_query_opts = 0
+          num_query_opts += 1 if wifi_id
+          num_query_opts += 1 if profile_id
+          num_query_opts += 1 if device_id
+          num_query_opts += 1 if wifi_name
+
+          
+          raise 'ERROR: Exactly one of: --wifi-id, --profile-id, --device-id, or --wifi-name must be specified.' if num_query_opts != 1
+
+          if wifi_id
+            wifi_config = EnfApi::Captive.instance.get_wifi_configuration wifi_id, version
+
+            # display the data
+            display_wifi_detail wifi_config
+
+          end
+        end
+      end
+
+      desc 'update-wifi-configuration',
+           'Update an existing wifi configuration.'
+      method_option :'wifi-id', defaut: nil, type: :string, banner: 'WIFI-ID',
+                                desc: 'WIFI-ID is the UUID of the wifi profile'
+      method_option :'wifi-config-file', type: :array, required: true,
+                                         banner: '<file>',
+                                         desc: '<file> is JSON file with ' \
+                                            'parameters required for ' \
+                                            'configuring the router card.'
+      def update_wifi_configuration
+        try_with_rescue_in_session do
+          json_file_name = options[:'wifi-config-file'].join(' ')
+          # read in the entire file - yes it is slurping the file, but it should
+          # never be bigger than a few KB.
+          content = File.read json_file_name
+          json_hash = JSON.parse(content)
+
+          resp_data = EnfApi::Captive.instance.update_wifi_configuration options[:'wifi-id'], json_hash
+          display_wifi_detail resp_data
+        end
+      end
+
+
+      desc 'create-device',
+           'Add a new device to the database. This is only available to Xaptum administrators'
+      method_option :'device-id', type: :string, required: true, banner: 'SERIAL-NUM',
+                                  desc: 'SERIAL-NUM is the serial number of the device.'
+      method_option :'device-name', type: :string, default: nil, banner: 'DEVICE-NAME',
+                                    desc: 'User-defined name for the device.'
+      method_option :'mac-addr1', type: :string, required: true, banner: 'MAC-ADDR1',
+                                  desc: 'MAC address 1 (wifi address on a wifi-enabled device)'
+      method_option :'mac-addr2', type: :string, required: true, banner: 'MAC-ADDR2',
+                                  desc: 'MAC address 2'
+      method_option :'mac-addr3', type: :string, required: true, banner: 'MAC-ADDR3',
+                                  desc: 'MAC address 3'
+      method_option :'mac-addr4', type: :string, required: true, banner: 'MAC-ADDR4',
+                                  desc: 'MAC address 4'
+      method_option :'profile-id', type: :string, default: nil, banner: 'PROFILE_ID',
+                                   desc: 'UUID of the profile that the device will use. The profile must already exist.'
+      def create_device
+        try_with_rescue_in_session do
+          new_device_hash = {
+            serial_number: options[:'device-id'],
+            mac_address: {
+              :wifi => options[:'mac-addr1'],
+              2 => options[:'mac-addr2'],
+              3 => options[:'mac-addr3'],
+              4 => options[:'mac-addr4']
+            }
+          }
+          dev_name = options[:'device-name']
+          profile = options[:profile_id]
+          new_device_hash[:device_name] = dev_name if dev_name
+          new_device_hash[:profile] = profile if profile
+
+          # send the new device request
+          device_data = EnfApi::Captive.instance.create_device new_device_hash
+
+          # display the response
+          display_device device_data
+        end
+      end
+
+      desc 'list-devices',
+           'List basic device information for all devices matching the option specified.'
+      method_option :network, default: nil, type: :string, banner: 'NETWORK',
+                              desc: 'NETWORK is the ipv6 subnet used by the device.'
+      def list_devices
+        try_with_rescue_in_session do
+          network = options[:network]
+          data = EnfApi::Captive.instance.list_devices network
+
+          display_device_list data
+        end
+      end
+
+      desc 'get-device',
+           'Get details of the specified device.'
+      method_option :'device-id', required: true, type: :string,
+                                  banner: 'DEVICE-ID',
+                                  desc: 'DEVICE-ID is either the device serial number or its ipv6 address.'
+      def get_device
+        try_with_rescue_in_session do
+          device_id = options[:'device-id']
+          data = EnfApi::Captive.instance.get_device device_id
+
+          display_device data
+        end
+      end
+
+      desc 'create-profile',
+           'Create a new profile.'
+      method_option :'profile-name', type: :string, required: true,
+                                     banner: 'PROFILE-NAME',
+                                     desc: 'PROFILE-NAME is the user-given name.'
+      method_option :'device-mode', type: :string, required: true,
+                                    banner: 'DEVICE-MODE',
+                                    desc: 'secure-host or passthrough'
+      method_option :'wifi-id', type: :string, default: nil, banner: 'WIFI-ID',
+                                desc: 'WIFI-ID is the UUID of the wifi record that the profile will use. wifi record must already exist'
+      def create_profile
+        try_with_rescue_in_session do
+          new_profile_hash = {
+            name: options[:'profile-name'],
+            config: {mode: options[:'device-mode']}
+          }
+
+          wifi = options[:'wifi-id']
+          if wifi
+            new_profile_hash[:config][:wifi] = {}
+            new_profile_hash[:config][:wifi][:id] = wifi
+          end
+
+          # send the POST to create a new profile
+          profile = EnfApi::Captive.instance.create_profile new_profile_hash
+          display_profile profile
+        end
+      end
+
+      desc 'list-profiles',
+           'List the existing profiles.'
+      method_option :name, default: nil, type: :string, banner: 'NAME',
+                           desc: 'where NAME will match all or part of the user-given profile name.'
+      def list_profiles
+        try_with_rescue_in_session do
+          query_name = options[:name]
+          profiles = EnfApi::Captive.instance.list_profiles query_name
+          display_profile_list profiles
+        end
+      end
+
+      desc 'get-profile',
+           'Get full detail listing of the profile.'
+      method_option :'profile-id', required: true, type: :string, 
+                                   banner: 'PROFILE-ID',
+                                   desc: 'PROFILE-ID is the UUID of the profile.'
+# TODO - server doesn't support version yet. 
+#      method_option :version, default: nil, type: :integer, banner: 'VERSION',
+#                              desc: 'Get a specific version.'
+      def get_profile
+        try_with_rescue_in_session do
+          profile = EnfApi::Captive.instance.get_profile options[:'profile-id']
+          display_profile profile
+        end
+      end
+
+      desc 'update-profile',
+           'Update a previously-created profile specified by PROFILE-ID.  At ' \
+           'least one property must be changed.'
+      method_option :'profile-id', required: true, type: :string, 
+                                   banner: 'PROFILE-ID',
+                                   desc: 'UUID of the device profile.'
+      method_option :'profile-name', type: :string, default: nil,
+                                     banner: 'PROFILE-NAME',
+                                     desc: 'PROFILE-NAME is the user-given name.'
+      method_option :'device-mode', type: :string, default: nil,
+                                    banner: 'DEVICE-MODE',
+                                    desc: 'secure-host or passthrough'
+      method_option :'wifi-id', type: :string, default: nil, banner: 'WIFI-ID',
+                                desc: 'WIFI-ID is the UUID of the wifi record that the profile will use. wifi record must already exist'
+      def update_profile
+        try_with_rescue_in_session do
+          id = options[:'profile-id']
+          name = options[:'profile-name']
+          mode = options[:'device-mode']
+          wifi_id = options[:'wifi-id']
+
+          raise "At least one option needs to change." if name == nil && mode == nil && wifi_id == nil
+
+          update_hash = {}
+          update_hash[:name] = name if name
+          if wifi_id || mode
+            update_hash[:config] = {}
+            update_hash[:config][:mode] = mode if mode
+            update_hash[:config][:wifi] = wifi_id if wifi_id
+          end
+
+          profile = EnfApi::Captive.instance.update_profile id, update_hash
+          display_profile profile
+
+        end
+      end
+
+
+      #########################################################################
+      #
+      # Helper functions
+      #
+      #########################################################################
+      no_commands do
+        # Displays the wifi configuration summary list.
+        # TODO - Does non-Xaptum-admin columns only - add option to do admin list
+        def display_wifi_configs(configs)
+          headings = ['ID', 'Wifi Name', 'Config Vers.']
+          rows = configs.map do |hash|
+            [hash[:id], hash[:name], hash[:version]]
+          end
+
+          render_table(headings, rows)
+        end
+
+        # Display a single wifi configuration in detail
+        def display_wifi_detail(wifi_data)
+          name = wifi_data[:name]
+          wifi_id = wifi_data[:id]
+          desc = wifi_data[:description]
+          configs = wifi_data[:config]
+
+          say "Wifi ID       : #{wifi_id}"
+          say "Name          : #{name}"
+          say "Description   : #{desc}"
+          say "WiFi Networks :"
+          configs.each do |wifi_net|
+            display_wifi_net(wifi_net, 1)
+          end
+
+        end
+
+        def display_wifi_net(wifi_net, tabs)
+          indent = "    " * tabs
+          say "Name          : #{wifi_net[:name]}"
+          say indent + "SSID          :#{wifi_net[:SSID]}"
+          say indent + "SSID type     :#{wifi_net[:SSID_type]}"
+
+          auth = wifi_net[:auth]
+          if auth
+            say indent + "auth          :#{auth[:type]}"
+          end
+
+          display_ipv4_addr(wifi_net[:IPv4], tabs)
+          display_ipv6_addr(wifi_net[:IPv6], tabs)
+        end
+
+        def display_ipv4_addr (ipv4, tabs)
+          indent = "    " * tabs
+          if ipv4.instance_of? String
+            say indent + "IPv4          :#{ipv4}"
+          elsif ipv4.instance_of? NilClass
+            say indent + "IPv4          :off"
+          elsif ipv4.instance_of? Hash
+            addr_type = ipv4[:type]
+            if addr_type == "dhcp"
+              say indent + "IPv4          :#{addr_type}"
+            elsif addr_type == "static"
+              addr = ipv4[:address]
+              mask = ipv4[:mask]
+              gw = ipv4[:gateway]
+              say indent + "IPv4          :#{addr}/#{mask}/#{gw}"
+            else
+              say indent + "*** Invalid ipv4 address. Type is #{addr_type} ***"
+            end
+          else
+            say indent + "*** Invalid ipv4 address. Received as JSON class: #{ipv4.class} ***"
+          end
+        end
+
+        def display_ipv6_addr (ipv6, tabs)
+          indent = "    " * tabs
+          if ipv6.instance_of? String
+            say indent + "IPv6          :#{ipv6}"
+          elsif ipv6.instance_of? NilClass
+            say indent + "IPv6          :off"
+          elsif ipv6.instance_of? Hash
+            addr_type = ipv6[:type]
+            if addr_type == "auto"
+              say indent + "IPv6          :#{addr_type}"
+            elsif addr_type == "static"
+              addr = ipv6[:address]
+              pref = ipv6[:prefix_length]
+              gw = ipv6[:gateway]
+              say indent + "IPv6          :#{addr}/#{pref}/#{gw}"
+            else
+              say indent + "*** Invalid ipv6 address. Type is #{addr_type} ***"
+            end
+          else
+            say indent + "*** Invalid ipv6 address. Received as JSON class: #{ipv6.class} ***"
+          end
+        end
+
+
+
+        #
+        # display the device info.
+        # device_data is a hash matching the json structure
+        #
+        def display_device(device_data)
+          name = device_data[:device_name]
+          ctl_addr = device_data[:control_address]
+          dev_addr = device_data[:device_address]
+          mac_addrs = device_data[:mac_address]
+          firmware = device_data[:firmware_version]
+          profile_id = device_data[:profile]
+          status = device_data[:status]
+
+          say "Serial Number     : #{device_data[:serial_number]}"
+          say "Device Name       : #{name}"
+          say "Control Address   : #{ctl_addr}"
+          say "Device Address    : #{dev_addr}"
+          say 'Mac Address       :'
+          if mac_addrs
+            say "              1   : #{mac_addrs[:wifi]}"
+            say "              2   : #{mac_addrs[:'2']}"
+            say "              3   : #{mac_addrs[:'3']}"
+            say "              4   : #{mac_addrs[:'4']}"
+          end
+          say "Firmware Version  : #{firmware}"
+          say "Profile ID        : #{profile_id}"
+          say "Status            : #{status}"
+        end
+
+        #
+        # display the devices summary list
+        #
+        def display_device_list(devices)
+          headings = ['Serial No', 'Dev Name', 'Dev Addr', 'Router Mode',
+                      'Connected', 'SSID']
+          rows = devices.map do |hash|
+            status = hash[:status]
+            if status
+              [hash[:serial_number], hash[:device_name], hash[:device_address],
+              status[:router_mode], status[:wifi][:connected],
+              status[:wifi][:SSID]]
+            else
+              [hash[:serial_number], hash[:device_name], hash[:device_address],
+              nil, nil, nil]
+            end
+          end
+          # [hash[:serial_number], hash[:device_name], hash[:device_address],
+          # hash[:status][:router_mode], hash[:status][:wifi][:connected],
+          # hash[:status][:wifi][:SSID]]
+
+          render_table(headings, rows)
+        end
+
+        #
+        # Display profile detail
+        #
+        def display_profile (profile)
+          say "Name                  :#{profile[:name]}"
+          say "Profile ID            :#{profile[:id]}"
+          say "Configuration version :#{profile[:config][:version]}"
+          say "Mode                  :#{profile[:config][:mode]}"
+          display_wifi_summary profile[:config][:wifi]
+        end
+
+        #
+        # Display summary of the WIFI configuration info
+        #
+        def display_wifi_summary (wifi)
+          say "Wifi config           :"
+          say "    id                :#{wifi[:id]}"
+          # TODO - make accessible only to Xaptum admins
+          say "    domain            :#{wifi[:domain]}"
+          say "    name              :#{wifi[:name]}"
+          desc = wifi[:description]
+          say "    description       :#{desc}" if desc
+          say "    config version    :#{wifi[:version]}"
+        end
+
+        #
+        # display the profile summary list
+        #
+        def display_profile_list(profiles)
+          headings = ['Profile Name', 'Profile ID', 'Version']
+          rows = profiles.map do |hash|
+            [hash[:name], hash[:id], hash[:config][:version]]
+          end
+
+          render_table(headings, rows)
+        end
+
+
+      end
+    end
+  end
+end