mtncloud-cli 1.0.0

data/lib/mtncloud/cli/credentials.rb

@@ -0,0 +1,482 @@
+require 'fileutils'
+require 'yaml'
+require 'json'
+require 'io/console'
+require 'rest_client'
+require 'mtncloud/logging'
+require 'mtncloud/cli/mixins/print_helper'
+
+module MtnCloud
+  module Cli
+    class Credentials
+      include MtnCloud::Cli::PrintHelper
+
+      @@appliance_credentials_map = nil
+
+      def initialize(appliance_name, appliance_url)
+        @appliance_name = appliance_name ? appliance_name.to_sym : nil
+        @appliance_url = appliance_url
+      end
+      
+      # request_credentials will fetch a credentials wallet (access_token, refresh_token, etc)
+      # By default this uses the saved credentials for the current appliance.
+      # If not logged in, it will prompt for username and password to
+      # authenticate with the /oauth/token API to receive an access_token.
+      # If :username and :password are passed, then
+      # Pass :remote_token to skip prompting and the auth api request.
+      # @param options - Hash of optional settings.
+      #   :username - Username for prompt.
+      #   :password - Password for prompt.
+      #   :remote_url - Use this url instead of the one from the current appliance. Credentials will not be saved.
+      #   :remote_token - Use this access_token, skip prompting and API request.
+      #   :remote_username - Username for authentication with --remote, skips saving credentials
+      #   :remote_password - Password for authentication with --remote, skips saving credentials
+      #   :test_only - Test only. Saved credentials will not be updated.
+      # @return Hash wallet like {"access_token":"ec68be138765...", "refresh_token":"ec68be138765..."} 
+      # or nil if unable to find credentials.
+      def request_credentials(options = {}, do_save=true)
+        #puts "request_credentials(#{options})"
+        username = nil
+        password = nil
+        wallet = nil
+
+        # should not need this logic in here
+        if options[:remote_url]
+          # @appliance_name = options[:remote_url] 
+          # name should change too though or printing may be misleading.
+          # @appliance_name = "remote-url"
+          # @appliance_url = options[:remote_url]
+          # do not save when using --remote-url
+          do_save = false
+        end
+
+        if options[:remote_token]
+          # user passed in a token to login with.
+          # this should get token info from /oauth/token
+          # OR whoami should return other wallet info like access token or maybe just the expiration date
+          # for now, it just stores the access token without other wallet info
+          begin
+            whoami_interface = MtnCloud::WhoamiInterface.new({url: @appliance_url, access_token: options[:remote_token], verify_ssl: !options[:insecure]})
+            whoami_interface.setopts(options)
+            if options[:dry_run]
+              print_dry_run whoami_interface.dry.get()
+              return nil
+            end
+            whoami_response = whoami_interface.get()
+            if options[:json]
+              puts as_json(whoami_response, options)
+              print reset, "\n"
+            end
+            # store mock /oauth/token  auth_interface.login() result
+            json_response = {'access_token' => options[:remote_token], 'token_type' => 'bearer'}
+            username = whoami_response['user']['username']
+            login_date = Time.now
+            expire_date = nil
+            if json_response['expires_in']
+              expire_date = login_date.to_i + json_response['expires_in'].to_i
+            end
+            wallet = {
+              'username' => username, 
+              'login_date' => login_date.to_i,
+              'expire_date' => expire_date ? expire_date.to_i : nil,
+              'access_token' => json_response['access_token'], 
+              'refresh_token' => json_response['refresh_token'], 
+              'token_type' => json_response['token_type']
+            }
+          rescue ::RestClient::Exception => e
+            #raise e
+            print_red_alert "Token not valid."
+            if options[:debug]
+              print_rest_exception(e, options)
+            end
+            wallet = nil
+          end
+        else
+          # ok prompt for creds..
+          username = options['username'] || options[:username] || nil
+          password = options['password'] || options[:password] || nil
+          
+          # what are these for? just use :username and :password
+          if options[:remote_username]
+            username = options[:remote_username]
+            password = options[:remote_password]
+          end
+          if wallet.nil?
+            unless options[:quiet] || options[:no_prompt]
+              print "Enter MTN Cloud Credentials for #{display_appliance(@appliance_name, @appliance_url)}", "\n", reset
+              if options[:client_id].empty?
+                # print "Client ID: #{required_blue_prompt} #{options[:client_id]}", "\n", reset
+              else
+                if options[:client_id] != MtnCloud::APIClient::CLIENT_ID
+                  print "Client ID: #{required_blue_prompt} #{options[:client_id]}", "\n", reset
+                end
+              end
+              if username.empty?
+                # print "Username: #{required_blue_prompt} "
+                # username = $stdin.gets.chomp!
+                Readline.completion_append_character = ""
+                Readline.basic_word_break_characters = ''
+                Readline.completer_word_break_characters = '' rescue nil
+                Readline.completion_proc = nil
+                username = Readline.readline("Username: #{required_blue_prompt} ", false).to_s.chomp
+              else
+                print "Username: #{required_blue_prompt} #{username}\n"
+              end
+              if password.empty?
+                # readline is still echoing secret with 'NUL:'' so just use $stdin on windows for now
+                # and some other environments? just use noecho unless running unit tests
+                if MtnCloud::Cli.windows? || !MtnCloud::Cli.testing?
+                  print "Password: #{required_blue_prompt} "
+                  # this should be my_terminal.stdin instead of STDIN and $stdin
+                  password = $stdin.noecho(&:gets).chomp!
+                  print "\n"
+                else                
+
+                  Readline.completion_append_character = ""
+                  Readline.basic_word_break_characters = ''
+                  Readline.completer_word_break_characters = '' rescue nil
+                  Readline.completion_proc = nil
+                  # needs to work like $stdin.noecho
+                  Readline.pre_input_hook = lambda {
+                    Readline.output = File.open('/dev/null', 'w')
+                    #Readline.output = File.open(MtnCloud::Cli.windows? ? 'NUL:' : '/dev/null', 'w')
+                    #$stdout = File.open(MtnCloud::Cli.windows? ? 'NUL:' : '/dev/null', 'w')
+                  }
+                  password = Readline.readline("Password: #{required_blue_prompt} ", false).to_s.chomp
+                  Readline.pre_input_hook = nil
+                  Readline.output = MtnCloud::Terminal.instance.stdout #my_terminal.stdout
+                  print "\n"
+                end
+              else
+                print "Password: #{required_blue_prompt} \n"
+              end
+            end
+            if username.empty? || password.empty?
+              print_red_alert "Username and password are required to login."
+              return nil
+            end
+            begin
+              auth_interface = MtnCloud::AuthInterface.new({url:@appliance_url, client_id: options[:client_id], verify_ssl: !options[:insecure]})
+              auth_interface.setopts(options)
+              if options[:dry_run]
+                print_dry_run auth_interface.dry.login(username, password)
+                return nil
+              end
+              json_response = auth_interface.login(username, password)
+              if options[:json]
+                print JSON.pretty_generate(json_response)
+                print reset, "\n"
+              end
+              #wallet = json_response
+              login_date = Time.now
+              expire_date = nil
+              if json_response['expires_in']
+                expire_date = login_date.to_i + json_response['expires_in'].to_i
+              end
+              wallet = {
+                'username' => username, 
+                'login_date' => login_date.to_i,
+                'expire_date' => expire_date ? expire_date.to_i : nil,
+                'access_token' => json_response['access_token'], 
+                'refresh_token' => json_response['refresh_token'], 
+                'token_type' => json_response['token_type']
+              }
+
+            rescue ::RestClient::Exception => e
+              #raise e
+              if (e.response && e.response.code == 400)
+                json_response = JSON.parse(e.response.to_s)
+                error_msg = json_response['error_description'] || "Credentials not verified."
+                print_red_alert error_msg
+                if options[:json]
+                  json_response = JSON.parse(e.response.to_s)
+                  print JSON.pretty_generate(json_response)
+                  print reset, "\n"
+                end
+              else
+                print_rest_exception(e, options)
+              end
+              wallet = nil
+            end
+
+          end
+        end
+
+        if do_save && @appliance_name
+          begin
+            # save pertinent session info to the appliance
+            save_credentials(@appliance_name, wallet)
+            now = Time.now.to_i
+            appliance = ::MtnCloud::Cli::Remote.load_remote(@appliance_name)
+            if wallet && wallet['access_token']
+              save_credentials(@appliance_name, wallet)
+            else
+              clear_saved_credentials(@appliance_name)
+            end
+            if appliance
+              if wallet && wallet['access_token']
+                # save wallet to credentials file
+                save_credentials(@appliance_name, wallet)
+                # save appliances file
+                appliance = ::MtnCloud::Cli::Remote.load_remote(@appliance_name)
+                appliance[:authenticated] = true
+                appliance[:username] = username
+                appliance[:status] = "ready"
+                appliance[:last_login_at] = now
+                appliance[:last_success_at] = now
+                ::MtnCloud::Cli::Remote.save_remote(@appliance_name, appliance)
+              else
+                # could be nice and not do this
+                #logout()
+                #save wallet to credentials file
+                clear_saved_credentials(@appliance_name)
+                now = Time.now.to_i
+                appliance = ::MtnCloud::Cli::Remote.load_remote(@appliance_name)
+                appliance[:authenticated] = false
+                old_username = appliance.delete(:username)
+                appliance[:last_logout_at] = Time.now.to_i
+                #appliance[:last_login_at] = now
+                #appliance[:error] = "Credentials not verified"
+                appliance.delete(:username)
+                ::MtnCloud::Cli::Remote.save_remote(@appliance_name, appliance)
+                if old_username
+                  print reset,"You have been automatically logged out. Goodbye #{old_username}!", reset, "\n"
+                end
+              end
+
+            end
+          rescue => e
+            MtnCloud::Logging::DarkPrinter.puts "failed to update remote appliance config: (#{e.class}) #{e.message}"
+          ensure
+            #::MtnCloud::Cli::Remote.recalculate_variable_map()
+          end
+        end
+        
+        return wallet
+      end
+
+      def login(options = {}, do_save=true)
+        request_credentials(options, do_save)
+      end
+
+      def logout()
+        clear_saved_credentials(@appliance_name)
+        # save pertinent session info to the appliance
+        appliance = ::MtnCloud::Cli::Remote.load_remote(@appliance_name)
+        if appliance
+          appliance.delete(:username) # could leave this...
+          appliance[:authenticated] = false
+          appliance[:last_logout_at] = Time.now.to_i
+          ::MtnCloud::Cli::Remote.save_remote(@appliance_name, appliance)
+        end
+        ::MtnCloud::Cli::Remote.recalculate_variable_map()
+        true
+      end
+
+      def use_refresh_token(refresh_token_value, options = {})
+        
+        wallet = load_saved_credentials
+
+        if wallet.nil?
+          print_red_alert yellow,"You are not currently logged in to #{display_appliance(@appliance_name, @appliance_url)}",reset,"\n"
+          return nil
+        end
+
+        if refresh_token_value.nil?
+          if wallet['refresh_token']
+            refresh_token_value = wallet['refresh_token']
+          else
+            print_red_alert yellow,"No refresh token found for #{display_appliance(@appliance_name, @appliance_url)}",reset,"\n"
+            return nil
+          end
+        end
+
+        username = wallet['username']
+
+        begin
+          auth_interface = MtnCloud::AuthInterface.new({url:@appliance_url, client_id: options[:client_id], verify_ssl: !options[:insecure]})
+          auth_interface.setopts(options)
+          if options[:dry_run]
+            print_dry_run auth_interface.dry.use_refresh_token(refresh_token_value)
+            return nil
+          end
+          json_response = auth_interface.use_refresh_token(refresh_token_value)
+          #wallet = json_response
+          login_date = Time.now
+          expire_date = nil
+          if json_response['expires_in']
+            expire_date = login_date.to_i + json_response['expires_in'].to_i
+          end
+          wallet = {
+            'username' => username, 
+            'login_date' => login_date.to_i,
+            'expire_date' => expire_date ? expire_date.to_i : nil,
+            'access_token' => json_response['access_token'], 
+            'refresh_token' => json_response['refresh_token'], 
+            'token_type' => json_response['token_type']
+          }
+          
+        rescue ::RestClient::Exception => e
+          #raise e
+          if (e.response && e.response.code == 400)
+            json_response = JSON.parse(e.response.to_s)
+            error_msg = json_response['error_description'] || "Refresh token not valid."
+            print_red_alert error_msg
+            if options[:json]
+              json_response = JSON.parse(e.response.to_s)
+              print JSON.pretty_generate(json_response)
+              print reset, "\n"
+            end
+          else
+            print_rest_exception(e, options)
+          end
+          wallet = nil
+          # return now or else it will log them out
+          return nil
+        end
+
+        # save wallet to credentials file
+        save_credentials(@appliance_name, wallet)
+
+        begin
+        # save pertinent session info to the appliance
+          now = Time.now.to_i
+          appliance = ::MtnCloud::Cli::Remote.load_remote(@appliance_name)
+          if appliance
+            if wallet && wallet['access_token']
+              appliance = ::MtnCloud::Cli::Remote.load_remote(@appliance_name)
+              appliance[:authenticated] = true
+              appliance[:username] = username
+              appliance[:status] = "ready"
+              appliance[:last_login_at] = now
+              appliance[:last_success_at] = now
+              ::MtnCloud::Cli::Remote.save_remote(@appliance_name, appliance)
+            else
+              now = Time.now.to_i
+              appliance = ::MtnCloud::Cli::Remote.load_remote(@appliance_name)
+              appliance[:authenticated] = false
+              #appliance[:username] = username
+              #appliance[:last_login_at] = now
+              #appliance[:error] = "Credentials not verified"
+              ::MtnCloud::Cli::Remote.save_remote(@appliance_name, appliance)
+            end
+          end
+        rescue => e
+          MtnCloud::Logging::DarkPrinter.puts "failed to update remote appliance config: (#{e.class}) #{e.message}"
+        end
+        
+        
+        return wallet
+      end
+
+      def clear_saved_credentials(appliance_name)
+        @@appliance_credentials_map = load_credentials_file || {}
+        @@appliance_credentials_map.delete(appliance_name.to_s)
+        @@appliance_credentials_map.delete(appliance_name.to_sym)
+        #MtnCloud::Logging::DarkPrinter.puts "clearing credentials for #{appliance_name} from file #{credentials_file_path}" if MtnCloud::Logging.debug?
+        File.open(credentials_file_path, 'w') {|f| f.write @@appliance_credentials_map.to_yaml } #Store
+        ::MtnCloud::Cli::Remote.recalculate_variable_map()
+        true
+      end
+
+      def load_saved_credentials(reload=false)
+        if reload || !defined?(@@appliance_credentials_map) || @@appliance_credentials_map.nil?
+          @@appliance_credentials_map = load_credentials_file || {}
+        end
+        # ok, we switched  symbols to strings, because symbols suck in yaml! need to support both
+        # also we switched from just a token (symbol) to a whole object of strings
+        wallet = @@appliance_credentials_map[@appliance_name.to_s] || @@appliance_credentials_map[@appliance_name.to_sym]
+        if wallet.is_a?(String)
+          wallet = {'access_token' => wallet}
+        end
+        return wallet
+      end
+
+      def load_credentials_file
+        fn = credentials_file_path
+        if File.exist? fn
+          #MtnCloud::Logging::DarkPrinter.puts "loading credentials file #{fn}" if MtnCloud::Logging.debug?
+          return YAML.load_file(fn)
+        else
+          return nil
+        end
+      end
+
+      def credentials_file_path
+        File.join(MtnCloud::Cli.home_directory, "credentials")
+      end
+
+      # credentials wallet is {'access_token': '...', 'refresh_token': '...' 'expiration': '2019-01-01...'}
+      def save_credentials(appliance_name, wallet)
+        # reloading file is better for now, otherwise you can lose credentials with multiple shells.
+        credential_map = load_credentials_file || {}
+        
+        if wallet
+          credential_map[appliance_name.to_s] = wallet
+        else
+          # nil mean remove the damn thing
+          credential_map.delete(appliance_name.to_s)
+        end
+        # always remove symbol, which was used pre 3.6.9
+        credential_map.delete(appliance_name.to_sym)
+        begin
+          fn = credentials_file_path
+          if !Dir.exist?(File.dirname(fn))
+            FileUtils.mkdir_p(File.dirname(fn))
+          end
+          #MtnCloud::Logging::DarkPrinter.puts "adding credentials for #{appliance_name} to #{fn}" if MtnCloud::Logging.debug?
+          File.open(fn, 'w') {|f| f.write credential_map.to_yaml } #Store
+          FileUtils.chmod(0600, fn)
+          @@appliance_credentials_map = credential_map
+        rescue => e
+          puts "failed to save #{fn}. #{e}"  if MtnCloud::Logging.debug?
+        ensure
+          # recalcuate echo vars
+          #puts "Recalculating variable maps for username change"
+          MtnCloud::Cli::Echo.recalculate_variable_map()
+          # recalculate shell prompt after this change
+          if MtnCloud::Cli::Shell.has_instance?
+            MtnCloud::Cli::Shell.instance.reinitialize()
+          end
+        end
+      end
+
+      def rename_credentials(appliance_name, new_appliance_name)
+        # reloading file is better for now, otherwise you can lose credentials with multiple shells.
+        credential_map = load_credentials_file || {}
+
+        if new_appliance_name.to_s.empty?
+          puts "Cannot rename credentials without specifying a new name" 
+          return nil
+        elsif credential_map[new_appliance_name.to_s] || credential_map[new_appliance_name.to_sym]
+          # yes you can, maybe require --force?
+          puts "Cannot rename credentials to a name that already exists: #{new_appliance_name}" 
+          return nil
+        end
+        
+        # always remove symbol, which was used pre 3.6.9
+        credential_map.delete(appliance_name.to_sym)
+        begin
+          fn = credentials_file_path
+          if !Dir.exist?(File.dirname(fn))
+            FileUtils.mkdir_p(File.dirname(fn))
+          end
+          #MtnCloud::Logging::DarkPrinter.puts "renaming credentials from #{appliance_name} to #{new_appliance_name}" if MtnCloud::Logging.debug?
+          File.open(fn, 'w') {|f| f.write credential_map.to_yaml } #Store
+          FileUtils.chmod(0600, fn)
+          @@appliance_credentials_map = credential_map
+        rescue => e
+          puts "failed to save #{fn}. #{e}"  if MtnCloud::Logging.debug?
+        ensure
+          # recalcuate echo vars
+          #puts "Recalculating variable maps for username change"
+          MtnCloud::Cli::Echo.recalculate_variable_map()
+          # recalculate shell prompt after this change
+          if MtnCloud::Cli::Shell.has_instance?
+            MtnCloud::Cli::Shell.instance.reinitialize()
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mtncloud/cli/dot_file.rb

@@ -0,0 +1,180 @@
+require 'fileutils'
+require 'time'
+require 'mtncloud/cli/cli_registry'
+require 'mtncloud/logging'
+require 'term/ansicolor'
+
+class MtnCloud::Cli::DotFile
+  include Term::ANSIColor
+
+  EXPORTED_ALIASES_HEADER = "# exported aliases"
+
+  # the path of the profile source file
+  # this is executed when `mtncloud` is run
+  def self.mtncloud_profile_filename
+    File.join(MtnCloud::Cli.home_directory, ".mtncloud_profile")
+  end
+
+  # the path of the shell source file
+  # this is executed when `mtncloud shell` is run
+  def self.mtncloudrc_filename
+    File.join(MtnCloud::Cli.home_directory, ".mtncloudrc")
+  end
+
+  attr_reader :filename
+  # attr_reader :file_contents
+  # attr_reader :commands
+  # attr_reader :cmd_results
+
+  def initialize(fn)
+    @filename = fn
+    #load_file()
+  end
+
+  # execute this file as a mtncloud shell script
+  # executes each line in the file as a mtncloud expression, ignores empty lines and comments '#'
+  # @return [Array] exit codes of all the commands that were run.
+  def execute()
+    if !File.exist?(@filename)
+      print "#{Term::ANSIColor.red}source file not found: #{@filename}#{Term::ANSIColor.reset}\n" # if MtnCloud::Logging.debug?
+    else
+      MtnCloud::Logging::DarkPrinter.puts "executing source file #{@filename}" if MtnCloud::Logging.debug?
+    end
+    file_contents = File.read(@filename)
+    lines = file_contents.split("\n")
+    cmd_results = []
+    line_num = 0
+    lines.each_with_index do |line, line_index|
+      line_num = line_index + 1
+      line = line.strip
+      next if line.empty?
+      next if line =~ /^\#/ # skip comments
+      
+      cmd_exit_code = 0
+      cmd_err = nil
+      cmd_result = nil
+      begin
+        cmd_result = MtnCloud::Cli::CliRegistry.exec_expression(line)
+      rescue SystemExit => err
+        if err.success?
+          cmd_result = true
+        else
+          puts "#{red} source file: #{@filename}, line: #{line_num}, command: #{line}, error: #{err}#{reset}"
+          cmd_result = false
+        end
+      rescue => err
+        # raise err
+        puts "#{red} source file: #{@filename}, line: #{line_num}, command: #{line}, error: #{err}#{reset}"
+        cmd_result = false
+      end
+      cmd_results << cmd_result
+    end
+    return cmd_results
+  end
+
+  # this saves the source file, upserting alias definitions at the bottom
+  # todo: smarter logic to allow the user to put stuff AFTER this section too
+  # under the section titled '# exported aliases'
+  # @param alias_definitions [Map] Map of alias_name => command_string
+  # @return nil
+  def export_aliases(alias_definitions)
+    if !@filename
+      print "#{Term::ANSIColor.dark}Skipping source file save because filename has not been set#{Term::ANSIColor.reset}\n" if MtnCloud::Logging.debug?
+      return false
+    end
+    if !Dir.exist?(File.dirname(@filename))
+      FileUtils.mkdir_p(File.dirname(@filename))
+    end
+    if !File.exist?(@filename)
+      print "#{Term::ANSIColor.dark}Initializing source file #{@filename}#{Term::ANSIColor.reset}\n" if MtnCloud::Logging.debug?
+      FileUtils.touch(@filename)
+    else
+      print "#{dark} #=> Saving source file #{@filename}#{reset}\n" if MtnCloud::Logging.debug?
+    end
+
+
+    config_text = File.read(@filename)
+    config_lines = config_text.split(/\n/)
+    new_config_lines = []
+    existing_alias_definitions = {}
+    header_line_index = config_lines.index {|line| line.strip.include?(EXPORTED_ALIASES_HEADER) }
+    # JD: there's some bad bug here where it can clear all your aliases!
+    # it would be safer to export to another file at .mtncloud/aliases or something.
+    if header_line_index
+      # keep everything before the exported alias section
+      new_config_lines = config_lines[0..header_line_index-1]
+      existing_alias_lines = config_lines[header_line_index..config_lines.size-1]
+      # parse out the existing alias definitions
+      existing_alias_lines.each do |line|
+        if line =~ /^alias\s+/
+          alias_name, command_string = MtnCloud::Cli::CliRegistry.parse_alias_definition(line)
+          if alias_name.empty? || command_string.empty?
+            print "#{dark} #=> removing bad config line #{line_num} invalid alias definition: #{line}\n" if MtnCloud::Logging.debug?
+          else
+            existing_alias_definitions[alias_name] = command_string
+          end
+        end
+      end
+    else
+      new_config_lines = config_lines
+      new_config_lines << "" # blank line before alias header
+    end
+
+    # append header line
+    new_config_lines << EXPORTED_ALIASES_HEADER
+    new_config_lines << "# Do not put anything below here, or it will be lost when aliases are exported"
+    #new_config_lines << ""
+
+    # update aliases, sort them, and append the lines
+    new_alias_definitions = existing_alias_definitions.merge(alias_definitions)
+    new_alias_definitions.keys.sort.each do |alias_name|
+      new_config_lines << "alias #{alias_name}='#{new_alias_definitions[alias_name]}'"
+    end
+    
+    # include a blank line after this section
+    new_config_lines << ""
+    new_config_lines << ""
+
+    new_config_text = new_config_lines.join("\n")
+    
+    File.open(@filename, 'w') {|f| f.write(new_config_text) }
+    return true
+  end
+
+  # this saves the source file, removing alias definitions at the bottom
+  # todo: smarter logic to allow the user to put stuff AFTER this section too
+  # under the section titled '# exported aliases'
+  # @param alias_definitions [Map] Map of alias_name => command_string
+  # @return nil
+  def remove_aliases(alias_names)
+    if !@filename
+      print "#{Term::ANSIColor.dark}Skipping source file save because filename has not been set#{Term::ANSIColor.reset}\n" if MtnCloud::Logging.debug?
+      return false
+    end
+    if !Dir.exist?(File.dirname(@filename))
+      FileUtils.mkdir_p(File.dirname(@filename))
+    end
+    if !File.exist?(@filename)
+      print "#{Term::ANSIColor.dark}Initializing source file #{@filename}#{Term::ANSIColor.reset}\n" if MtnCloud::Logging.debug?
+      FileUtils.touch(@filename)
+    else
+      print "#{dark} #=> Saving source file #{@filename}#{reset}\n" if MtnCloud::Logging.debug?
+    end
+
+
+    config_text = File.read(@filename)
+    config_lines = config_text.split(/\n/)
+    
+    new_config_lines = config_lines.reject {|line|
+      alias_names.find {|alias_name| /^alias\s+#{Regexp.escape(alias_name)}\s?\=/ }
+    }
+    
+    new_config_text = new_config_lines.join("\n")
+    
+    File.open(@filename, 'w') {|f| f.write(new_config_text) }
+    return true
+  end
+
+
+
+end