vps_cli 0.1.4

data/lib/vps_cli/configurations/default_configuration.rb

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+
+require 'vps_cli'
+
+VpsCli.configure do |config|
+  # Where items will be copied to
+  # For example, the local dir is where you would your dotfiles
+  # saved to
+  config.local_dir = Dir.home
+  config.backup_dir = File.join(Dir.home, 'backup_files')
+  config.local_sshd_config = File.join('/etc', 'ssh', 'sshd_config')
+
+  # You must set these values yourself
+
+  # Location of your config files
+  # config.config_files = File.join(Dir.home, 'config_files')
+  # This is just used for easier git pulling and git pushing
+
+  config.config_files = File.join(Dir.home, 'vps_setup')
+
+  # Location of your dotfiles
+  # config.dotfiles = File.join(Dir.home, 'vps_setup', 'dotfiles')
+  config.dotfiles = File.join(config.config_files, 'dotfiles')
+
+  # Location of your dotfiles
+  # config.dotfiles = File.join(Dir.home, 'config_files', 'dotfiles')
+  config.misc_files = File.join(config.config_files, 'misc_files')
+
+  # credentials.yaml file, wherever its located, for me I have it in the home dir
+  config.credentials = File.join(Dir.home, '.credentials.yaml')
+
+  # location of your .netrc file, usually ~/.netrc
+  config.netrc = File.join(Dir.home, '.netrc')
+
+  config.verbose = false
+
+  # Change to false if you dont want to be prompted
+  # about file creations / overwrites
+  config.interactive = true
+
+  # this is merely for testing purposes, dont worry about this
+  config.testing = false
+end
+

data/lib/vps_cli/configurations/testing_configuration.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+
+require 'vps_cli'
+
+test_dir = File.expand_path('../../../test', __dir__)
+
+VpsCli.configure do |config|
+  config.local_dir = File.join(test_dir, 'local_dir')
+  config.backup_dir = File.join(test_dir, 'backup_dir')
+  config.local_sshd_config = File.join(config.local_dir, 'sshd_config')
+  config.sshd_backup = File.join(config.backup_dir, 'sshd_config.orig')
+
+  config.config_files = File.join(test_dir, 'config_files')
+  config.misc_files = File.join(config.config_files, 'miscfiles')
+  config.dotfiles = File.join(config.config_files, 'dotfiles')
+  config.credentials = File.join(File.expand_path('../../../', __dir__), 'example_credentials.yaml')
+  config.netrc = File.join(test_dir, 'access_dir', 'netrc')
+
+
+  config.verbose = true
+  config.interactive = false
+  config.testing = true
+end
+
+# puts VpsCli.configuration.local_dir

data/lib/vps_cli/copy.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require 'rake'
+
+require 'vps_cli/helpers/file_helper'
+
+module VpsCli
+  # Copies config from /vps_cli/config_files/dotfiles
+  #   & vps_cli/config_files/miscfiles to your home dir
+  class Copy
+    extend FileHelper
+
+    # Top level method for copying all files
+    # Will use the configurations set by VpsCli.configuration
+    #   unless passed a different config
+    # @raise [RuntimeError]
+    #   Will raise this error if you run this method as root or sudo
+    def self.all(config = VpsCli.configuration)
+      # raises an error if the script is run as root
+      return unless root? == false
+
+      # fills in options that are not explicitly filled in
+      FileHelper.mkdirs(config.local_dir, config.backup_dir)
+
+      # copies dotfiles
+      dotfiles(config)
+
+      # copies gnome_settings
+      gnome_settings(config)
+
+      # copies sshd_config
+      sshd_config(config)
+
+      puts "dotfiles copied to #{config.local_dir}"
+      puts "backups created @ #{config.backup_dir}"
+    end
+
+    # Copy files from 'config_files/dotfiles' directory via the copy_all method
+    # Defaults are provided in the VpsCli.create_options method
+    # @see VpsCli::Configuration
+    def self.dotfiles(config = VpsCli.configuration)
+      Dir.each_child(config.dotfiles) do |file|
+        config_file = File.join(config.dotfiles, file)
+        local = File.join(config.local_dir, ".#{file}")
+        backup = File.join(config.backup_dir, "#{file}.orig")
+
+        files_and_dirs(config_file: config_file,
+                       local_file: local,
+                       backup_file: backup,
+                       verbose: config.verbose,
+                       interactive: config.interactive)
+      end
+    end
+
+    # Checks that sshd_config is able to be copied
+    # @param sshd_config [File] File containing your original sshd_config
+    #   Defaults to /etc/ssh/sshd_config
+    # @return [Boolean] Returns true if the sshd_config exists
+    def self.sshd_copyable?(sshd_config = nil)
+      sshd_config ||= '/etc/ssh/sshd_config'
+
+      no_sshd_config = 'No sshd_config found. sshd_config not copied'
+
+      return true if File.exist?(sshd_config)
+
+      VpsCli.errors << Exception.new(no_sshd_config)
+    end
+
+    # Copies sshd_config to the VpsCli.configuration.local_sshd_config
+    #   location
+    #   Defaults to [/etc/ssh/sshd_config] if not set
+    #   This is slightly different from other copy methods in this file
+    #   It uses Rake.sh("sudo cp")
+    #   Due to copying to /etc/ssh/sshd_config requiring root permissions
+    def self.sshd_config(config = VpsCli.configuration)
+
+      config.local_sshd_config ||= File.join('/etc', 'ssh', 'sshd_config')
+      return unless sshd_copyable?(config.local_sshd_config)
+
+      config.sshd_backup ||= File.join(config.backup_dir, 'sshd_config.orig')
+
+      misc_sshd_path = File.join(config.misc_files, 'sshd_config')
+
+      if File.exist?(config.local_sshd_config) && !File.exist?(config.sshd_backup)
+        Rake.cp(config.local_sshd_config, config.sshd_backup)
+      else
+        puts "#{config.sshd_backup} already exists. no backup created"
+      end
+
+      return Rake.cp(misc_sshd_path, config.local_sshd_config) if config.testing
+
+      # This method must be run this way due to it requiring root privileges
+      unless FileHelper.overwrite?(config.local_sshd_config, config.interactive)
+        return
+      end
+
+      Rake.sh("sudo cp #{misc_sshd_path} #{config.local_sshd_config}")
+    end
+
+    # Deciphers between files & directories
+    # Also utilizes the settings from your configuration to properly
+    #   copy things
+    # @see VpsCli::FileHelper#copy_dirs
+    # @see VpsCli::FileHelper#copy_files
+    def self.files_and_dirs(opts = {})
+      if File.directory?(opts[:config_file])
+        FileHelper.copy_dirs(opts)
+      else
+        FileHelper.copy_files(opts)
+      end
+    end
+
+    # Copies gnome terminal via dconf
+    # @see https://wiki.gnome.org/Projects/dconf dconf wiki
+    # @param config [VpsCli::Configuration] Where to save the current gnome terminal settings
+    # @note This method will raise an error if dconf errors out
+    #   The error will be saved to VpsCli.errors
+    def self.gnome_settings(config = VpsCli.configuration)
+      backup = "#{config.backup_dir}/gnome_terminal_settings.orig"
+
+      # This is the ONLY spot for gnome terminal
+      gnome_path = '/org/gnome/terminal/'
+      gnome_file = File.join(config.misc_files, 'gnome_terminal_settings')
+
+      raise RuntimeError if config.testing
+      raise RuntimeError unless File.exists?(gnome_file)
+
+      overwrite = proc { |file| FileHelper.overwrite?(file, config.interactive) }
+      Rake.sh("dconf dump #{gnome_path} > #{backup}") if overwrite.call(backup)
+
+      dconf_load = "dconf load #{gnome_path} < #{config.misc_files}/gnome_terminal_settings"
+      Rake.sh(dconf_load) if overwrite.call(gnome_path)
+    rescue RuntimeError => error
+      puts 'something went wrong with gnome, continuing on' if config.verbose
+      VpsCli.errors << error
+    end
+
+    def self.root?
+      root = (Process.uid.zero? || Dir.home == '/root')
+      root_msg = 'Do not run this as root or sudo. Run as a normal user'
+      raise root_msg if root == true
+
+      false
+    end
+  end
+end

data/lib/vps_cli/helpers/access_helper.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+# @see https://ruby-doc.org/stdlib-2.6.0.preview2/libdoc/open3/rdoc/Open3.html
+require 'open3'
+require 'json'
+require 'net/http'
+
+# Helper methods to be used within Access to help reduce the file size
+module AccessHelper
+  # retrieves the values of .netrc for heroku and creates a writable string
+  # @return [String] Returns the string to be written to netrc
+  def heroku_api_string(yaml_file:)
+    # initial tree traversal in the .yaml file
+    heroku_api = %i[heroku api]
+    heroku_api_keys = %i[machine login password]
+
+    make_string(base: heroku_api, keys: heroku_api_keys) do |path|
+      decrypt(yaml_file: yaml_file, path: path)
+    end
+  end
+
+  # retries the git values for heroku in your .yaml file
+  # @return [String] Returns the string to be written to your netrc file
+  def heroku_git_string(yaml_file:)
+    heroku_git = %i[heroku git]
+    heroku_git_keys = %i[machine login password]
+
+    make_string(base: heroku_git, keys: heroku_git_keys) do |path|
+      decrypt(yaml_file: yaml_file, path: path)
+    end
+  end
+
+  # my version of Enumerable#inject intended to return a string
+  # provides a count to know what # object youre on
+  # @param array [Array<#to_s>]
+  #   For each element in the array, yield to the block given.
+  # @yieldparam accum [String]
+  #   The value that will persist throughout the block
+  # @yieldparam element [String] The current element in the array
+  # @yield param count [Integer]
+  # @return [String] Returns the string returned by the block passed to it
+  def my_inject_with_count(array)
+    value = nil
+    count = 0
+    array.inject('') do |accum, element|
+      value = yield(accum, element, count)
+      count += 1
+      value # if not here, returns the value of count
+    end
+  end
+
+  # Creates a string to be used to write to .netrc
+  # @param base [String] Provides the base string from which to add to
+  # @param keys [Array<String>] An array of strings to append to base
+  # @return [String] Returns the string after concatenating them
+  def make_string(base:, keys:)
+    # iterates through the keys to provide a path to each array
+    # essentialy is the equivalent of Hash.dig(:heroku, :api, :key)
+    my_inject_with_count(keys) do |string, key, count|
+      path = dig_for_path(base, key)
+
+      value = yield(path)
+      value << "\n  " if count < keys.length - 1
+      string + value
+    end
+  end
+
+  # Writes the value of string to netrc
+  # @param netrc_file [File] ($HOME/.netrc)
+  #   The location of your .netrc file to be read by heroku
+  # @param string [String] The String to write to the netrc file
+  # @return void
+  def write_to_netrc(netrc_file: nil, string:)
+    netrc_file ||= File.join(Dir.home, '.netrc')
+    Rake.mkdir_p(File.dirname(netrc_file))
+    Rake.touch(netrc_file) unless File.exist?(netrc_file)
+
+    begin
+      File.write(netrc_file, string)
+    rescue Errno::EACCES => e
+      netrc_error(netrc_file: netrc_file, error: e)
+    end
+  end
+
+  # Adds the error to VpsCli#errors array
+  # @param [File] Location of netrc_file
+  # @param [Exception] The error to write to the array
+  # @return void
+  def netrc_error(netrc_file:, error:)
+    error_msg = "Unable to write to your #{netrc_file}."
+    VpsCli.errors << error.exception(error_msg)
+  end
+
+  # uses an access file via SOPS
+  # SOPS is an encryption tool
+  # @see https://github.com/mozilla/sops
+  # It will decrypt the file, please use a .yaml file
+  # @param file [File]
+  #   The .yaml file encrypted with sops used to login to various accounts
+  # @path [String] JSON formatted string to traverse
+  #   a yaml file tree
+  #   Example: "[\"github\"][\"username\"]"
+  # @return [String] The value of key given in the .yaml file
+  def decrypt(yaml_file:, path:)
+    # puts all keys into a ["key"] within the array
+    sops_cmd = "sops -d --extract '#{path}' #{yaml_file}"
+
+    # this allows you to enter your passphrase
+    export_tty
+    # this will return in the string form the value you were looking for
+    stdout, _stderr, _status = Open3.capture3(sops_cmd)
+
+    stdout
+  end
+
+  # @param [#to_s, Array<#to_s>] The ordered path to traverse
+  # @return [String] Returns a path string to be able to traverse a yaml file
+  # @see VpsCli::Access#decrypt
+  def dig_for_path(*path)
+    path.flatten.inject('') do |final_path, node|
+      final_path + "[#{node.to_s.to_json}]"
+    end
+  end
+
+  # I noticed needing to export $(tty) while troubleshooting
+  # issues with gpg keys. It is here just in case its not in
+  # your zshrc / bashrc file
+  # @return void
+  def export_tty
+    Rake.sh('GPG_TTY=$(tty) && export GPG_TTY')
+  end
+end

data/lib/vps_cli/helpers/file_helper.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require 'rake'
+
+# Used for copying files, making directories, copying directories etc
+module FileHelper
+  # Helper method for making multiple directories
+  # @param [Dir, Array<Dir>] Creates either one, or multiple directories
+  def self.mkdirs(*dirs)
+    dirs.flatten.each { |dir| Rake.mkdir_p(dir) unless Dir.exist?(dir) }
+  end
+
+  # Copies files, called by copy_all
+  # @see VpsCli::Copy#all
+  # @param [Hash] opts The options to copy with
+  # @option opts [File] :config_file The file from the repo to be copied locally
+  # @option opts [File] :local_file The file that is currently present locally
+  # @option opts [File] :backup_file
+  #   The file to which to save the currently present local file
+  # @option opts [Boolean] :interactive
+  #   Will prompt yes or no for each file it creates
+  # @option opts [Boolean] :verbose Will print more info to terminal if true
+  def self.copy_files(opts = {})
+    # if there is an original dot file & no backup file in the backupdir
+    # Copy the dot file to the backup dir
+    if create_backup?(opts)
+      copy_file(opts[:local_file], opts[:backup_file], opts[:interactive])
+    end
+
+    # Copies from vps_cli/dotfiles to the location of the dot_file
+    copy_file(opts[:config_file], opts[:local_file], opts[:interactive])
+  end
+
+  # Copies directories instead of files, called by copy_all
+  # @see VpsCli::Copy#all
+  # @param [Hash] opts The options to copy with
+  # @option opts [File] :config_file The file from the repo to be copied locally
+  # @option opts [File] :dot_file The file that is currently present locally
+  # @option opts [File] :backup_file
+  #   The file to which to save the currently present local file
+  # @option opts [Boolean] :interactive
+  #   Will prompt yes or no for each file it creates
+  # @option opts [Boolean] :verbose Will print more info to terminal if true
+  def self.copy_dirs(opts = {})
+    mkdirs(opts[:local_file])
+
+    if create_backup?(opts)
+      copy_dir(opts[:local_file], opts[:backup_file], opts[:interactive])
+    end
+
+    Dir.each_child(opts[:config_file]) do |dir|
+      dir = File.join(opts[:config_file], dir)
+
+      # copies to local dir
+      copy_dir(dir, opts[:local_file], opts[:interactive])
+    end
+  end
+
+  # Checks that a backup file does not exist
+  # @param file [File] File to be searched for
+  # @param verbose [Boolean] Will print to console if verbose == true
+  # @return [Boolean] Returns true if the file is not found
+  def self.backup_file_not_found?(file, verbose = false)
+    return true unless File.exist?(file)
+
+    puts "#{file} exists already. No backup created." if verbose
+    false
+  end
+
+  # Helper method for determining whether or not to create a backup file
+  # @param opts [Hash] options hash
+  # @option [File] :local_file current dot file
+  # @option [File] :backup_file Where to back the dot file up to
+  # @option [Boolean] :verbose Will print to terminal if verbose == true
+  # @return [Boolean] Returns true if there is a dotfile that exists
+  #   And there is no current backup_file found
+  def self.create_backup?(opts = {})
+    return false unless file_found?(opts[:local_file], opts[:verbose])
+    unless backup_file_not_found?(opts[:backup_file], opts[:verbose])
+      return false
+    end
+
+    true
+  end
+
+  # Default way of checking if the dotfile already exists
+  # @param file [File] File to be searched for
+  # @param verbose [Boolean] Will print to console if verbose == true
+  # @return [Boolean] Returns true if the file exists
+  def self.file_found?(file, verbose = false)
+    return true if File.exist?(file)
+
+    puts "#{file} does not exist. No backup created." if verbose
+    false
+  end
+
+  def self.retrieve_file(directory, name)
+    Dir.children(directory).select { |file| name == file }
+  end
+
+  # base method to copy a file and ask for permission prior to copying
+  # @see copy_files
+  # @see ask_permission
+  # @param from [File] File to copy from
+  # @param to [File] File to copy to
+  # @param config [VpsCli::Configuration] (VpsCli#configuration)
+  #   uses the default config provided by the VpsCli module
+  def self.copy_file(from, to, interactive = false)
+    Rake.cp(from, to) if overwrite?(to, interactive)
+  end
+
+  # base method to copy a dir and ask for permission prior to copying
+  # @see copy_dirs
+  # @see ask_permission
+  # @param from [Dir] Directory to copy from
+  # @param to [Dir] Directory to copy to
+  # @param interactive [Boolean] (false) asks whether or not to create the file
+  def self.copy_dir(from, to, interactive = false)
+    mkdirs(to)
+    to_path = File.join(to, File.basename(from))
+    Rake.cp_r(from, to) if overwrite?(to_path, interactive)
+  end
+
+  # asks permission to copy a file
+  # @param file [File] The file to copy to
+  # @param interactive [Boolean] (false) If interactive equals false
+  #   then automatically overwrite
+  # @return [Boolean]
+  #   Decides whether or not the file will be created / overwritted
+  def self.overwrite?(file, interactive = false)
+    return true if interactive == false
+
+    string = "Attempting to overwrite file #{file}" if File.exist?(file)
+    string ||= "Attempting to create file #{file}"
+
+    # +string is equivalent to string.dup
+    string = +string + ' Is this okay? (Y/N)'
+
+    loop do
+      puts string
+      input = $stdin.gets.chomp.downcase.to_sym
+      return true if input == :y
+      return false if input == :n
+    end
+  end
+end

data/lib/vps_cli/helpers/github_http.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'net/http'
+
+module VpsCli
+  # An http wrapper for github api request
+  class GithubHTTP
+    attr_accessor :uri, :title
+    attr_writer :token, :ssh_file
+
+    # @param uri [URI] the url to hit
+    # @param token [String] Github API token to use
+    # @param ssh_key [String] Your ssh file IE: ~/.ssh/id_rsa.pub
+    # @param title [String] The title of your ssh key
+    #   Ensure it is in the format: "token 14942842859"
+    def initialize(uri:, token:, ssh_file:, title:)
+      @uri = uri
+      @token = token
+      @ssh_file = ssh_file
+      @ssh_key = File.read(ssh_file)
+      @headers = headers(token: token)
+      @title = title
+    end
+
+    # The headers need for authorization of a request
+    # @param token [String] (nil) Your github API token
+    #   @see https://github.com/settings/keys
+    #   make sure your token has write:public_key and read:public_key access
+    # @return [Hash] Returns a hash of headers
+    def headers(token:)
+      json = 'application/json'
+
+      { 'Content-Type' => json,
+        'Accepts' => json,
+        'Authorization' => token }
+    end
+
+    # Returns the appropriate json string to write an ssh key
+    # @return [String] Returns a json formatted string to write an ssh key
+    def ssh_json_string
+      { 'title' => @title,
+        'key' => @ssh_key }.to_json
+    end
+
+    # base method for an http connection
+    # @yieldparam http [Net::HTTP] yields the http class
+    # @return Whatever the value of yield is
+    def start_connection
+      Net::HTTP.start(@uri.host, @uri.port, use_ssl: true) do |http|
+        yield(http)
+      end
+    end
+
+    # Pushes your public key to github
+    # to push your ssh key to the github
+    # @return Net::HTTPResponse
+    def push_ssh_key
+      get = get_request
+
+      post = post_request(data: ssh_json_string)
+
+      response = start_connection do |http|
+        get_response = http.request(get)
+
+        ssh_keys_json = get_response.body
+        return ssh_key_found_msg if ssh_key_exist?(json_string: ssh_keys_json)
+
+        http.request(post)
+      end
+
+      VpsCli.errors << response if response != Net::HTTPCreated
+
+      puts 'ssh key pushed to github' if response.class == Net::HTTPCreated
+      response
+    end
+
+    # @param token [String] Your github api token
+    # @return [Net::HTTP::Get] Returns a new get request class
+    def get_request
+      Net::HTTP::Get.new(@uri, @headers)
+    end
+
+    # @param data [String] The data to send in the post request, must be json
+    # @return [Net::HTTP::Post] Returns a new post request class
+    def post_request(data:)
+      post = Net::HTTP::Post.new(@uri, @headers)
+      post.body = data
+      post
+    end
+
+    # Checks if the ssh key is already found
+    def ssh_key_exist?(json_string:)
+      # just in case your ssh key has a comment in it
+      # keys pulled from github will not have comments
+      ssh_key = @ssh_key.split('==')[0].concat('==')
+
+      JSON.parse(json_string).any? do |data|
+        data['key'] == ssh_key
+      end
+    end
+
+    def ssh_key_found_msg
+      puts 'The ssh key provided is already on github, no post request made.'
+    end
+  end
+end