fenton_shell 0.1.0

data/lib/fenton_shell.rb

@@ -0,0 +1,15 @@
+require 'excon'
+require 'json'
+require 'fileutils'
+require 'sshkey'
+require 'highline/import'
+
+require 'fenton_shell/version'
+
+require 'fenton_shell/config_file'
+require 'fenton_shell/key'
+
+require 'fenton_shell/organization'
+require 'fenton_shell/client'
+require 'fenton_shell/project'
+require 'fenton_shell/certificate'

data/lib/fenton_shell/certificate.rb

@@ -0,0 +1,83 @@
+module FentonShell
+  # Interfaces with the certificate api on fenton server
+  class Certificate
+    # @!attribute [r] message
+    #   @return [String] success or failure message and why
+    attr_accessor :message
+
+    # Creates a new certificate on fenton server by sending a post
+    # request with json from the command line to create the certificate
+    #
+    # @param global_options [Hash] global command line options
+    # @param options [Hash] json fields to send to fenton server
+    # @return [String] success or failure message
+    def create(global_options, options)
+      status, body = certificate_create(global_options, options)
+
+      if status == 201
+        save_message('Certificate': ['created!'])
+        true
+      else
+        save_message(body)
+        false
+      end
+    end
+
+    private
+
+    # Sends a post request with json from the command line certificate
+    #
+    # @param global_options [Hash] global command line options
+    # @param options [Hash] json fields to send to fenton server
+    # @return [Fixnum] http status code
+    # @return [String] message back from fenton server
+    def certificate_create(global_options, options)
+      result = Excon.post(
+        "#{global_options[:fenton_server_url]}/certificates.json",
+        body: certificate_json(options),
+        headers: { 'Content-Type' => 'application/json' }
+      )
+
+      write_client_certificate(
+        public_key_cert_location(options[:public_key]),
+        JSON.parse(result.body)['data']['attributes']['certificate']
+      )
+
+      [result.status, JSON.parse(result.body)]
+    end
+
+    def write_client_certificate(file_path, content)
+      File.write(file_path, content)
+      File.chmod(0o600, file_path)
+    end
+
+    def public_key_cert_location(public_key_location)
+      public_key_location.gsub(%r{\.pub}, '-cert.pub')
+    end
+
+    # Formulates the certificate json for the post request
+    #
+    # @param options [Hash] fields from fenton command line
+    # @return [String] json created from the options hash
+    def certificate_json(options)
+      {
+        certificate: {
+          client: options[:client],
+          project: options[:project]
+        }
+      }.to_json
+    end
+
+    # Helps output the error message from fenton server
+    #
+    # @param msg [Hash] fields from fenton public classes
+    # @return [String] changed hash fields to string for command line output
+    def save_message(msg = {})
+      self.message ||= ''
+
+      msg.each do |key, value|
+        self.message << "#{key.capitalize} #{value.first}\n"
+      end
+    end
+  end
+end

data/lib/fenton_shell/client.rb

@@ -0,0 +1,92 @@
+module FentonShell
+  # Interfaces with the client api on fenton server
+  class Client
+    # @!attribute [r] message
+    #   @return [String] success or failure message and why
+    attr_accessor :message
+
+    # Creates a new client on fenton server by sending a post
+    # request with json from the command line to create the client
+    #
+    # @param global_options [Hash] global command line options
+    # @param options [Hash] json fields to send to fenton server
+    # @return [String] success or failure message
+
+    def create(global_options, options)
+      status, body = client_create(global_options, options)
+
+      if status == 201
+        save_message('Client': ['created!'])
+        true
+      else
+        save_message(body)
+        false
+      end
+    end
+
+    # Calls create new client then creates an organization for that client
+    # via a post request with json from the command line
+    #
+    # @param global_options [Hash] global command line options
+    # @param options [Hash] json fields to send to fenton server
+    # @return [String] success or failure message
+
+    def create_with_organization(global_options, options)
+      create(global_options, options)
+
+      if Organization.new.create(global_options, name: options[:username],
+                                                 key: options[:username])
+        save_message('Organization': ['created!'])
+        true
+      else
+        save_message('Organization': ['not created!'])
+        false
+      end
+    end
+
+    private
+
+    # Sends a post request with json from the command line client
+    #
+    # @param global_options [Hash] global command line options
+    # @param options [Hash] json fields to send to fenton server
+    # @return [Fixnum] http status code
+    # @return [String] message back from fenton server
+    def client_create(global_options, options)
+      result = Excon.post(
+        "#{global_options[:fenton_server_url]}/clients.json",
+        body: client_json(options),
+        headers: { 'Content-Type' => 'application/json' }
+      )
+
+      [result.status, JSON.parse(result.body)]
+    end
+
+    # Formulates the client json for the post request
+    #
+    # @param options [Hash] fields from fenton command line
+    # @return [String] json created from the options hash
+    def client_json(options)
+      {
+        client: {
+          username: options[:username],
+          name: options[:name],
+          email: options[:email],
+          public_key: File.read(options[:public_key])
+        }
+      }.to_json
+    end
+
+    # Helps output the error message from fenton server
+    #
+    # @param msg [Hash] fields from fenton public classes
+    # @return [String] changed hash fields to string for command line output
+    def save_message(msg = {})
+      self.message ||= ''
+
+      msg.each do |key, value|
+        self.message << "#{key.capitalize} #{value.first}\n"
+      end
+    end
+  end
+end

data/lib/fenton_shell/config_file.rb

@@ -0,0 +1,122 @@
+module FentonShell
+  # Provides a local configuration file
+  class ConfigFile
+    # @!attribute [r] message
+    #   @return [String] success or failure message and why
+    attr_accessor :message
+
+    # Creates a configuration file on the local file system
+    #
+    # @param global_options [Hash] global command line options
+    # @param options [Hash] fields to send to create the configuration file
+    # @return [String] success or failure message
+
+    def create(global_options, options)
+      status, body = config_file_create(global_options, options)
+
+      if status
+        save_message('ConfigFile': ['created!'])
+        true
+      else
+        save_message(body)
+        false
+      end
+    end
+
+    class << self
+      # Responds with the default organization
+      #
+      # @param global_options [Hash] global command line options
+      # @return [String] default organization key for client
+      def default_organization(global_options)
+        config_file(global_options)[:default_organization]
+      end
+
+      # Responds with the default username
+      #
+      # @param global_options [Hash] global command line options
+      # @return [String] default username for client
+      def username(global_options)
+        config_file(global_options)[:username]
+      end
+
+      # Responds with the default public key
+      #
+      # @param global_options [Hash] global command line options
+      # @return [String] default public key for client
+      def public_key(global_options)
+        config_file(global_options)[:public_key]
+      end
+
+      private
+
+      # Loads the configuration file content
+      #
+      # @param global_options [Hash] global command line options
+      # @return [Hash] content from yaml config file
+      def config_file(global_options)
+        YAML.load_file("#{global_options[:directory]}/config")
+      end
+    end
+
+    private
+
+    # Creates the configuration file
+    #
+    # @param options [Hash] fields from fenton command line
+    # @return [Object] true or false
+    # @return [String] message on success or failure
+    def config_file_create(global_options, options)
+      config_directory_create(global_options)
+
+      file = "#{global_options[:directory]}/config"
+      options.store(:fenton_server_url, global_options[:fenton_server_url])
+      content = config_generation(options)
+      File.write(file, content)
+
+      [true, 'ConfigFile': ['created!']]
+    end
+
+    # Generates the configuration file content
+    #
+    # @param options [Hash] fields from fenton command line
+    # @return [String] true or false
+    def config_generation(options)
+      config_contents = {}
+
+      config_options = options.keys.map(&:to_sym).sort.uniq
+      config_options.delete(:password)
+      config_options.each do |config_option|
+        config_contents.store(config_option.to_sym, options[config_option])
+      end
+
+      config_contents.store(:default_organization, options[:username])
+
+      config_contents.to_yaml
+    end
+
+    def config_directory_create(global_options)
+      FileUtils.mkdir_p(global_options[:directory])
+    rescue Errno::EEXIST => e
+      if e.message =~ %r{File exists}
+        save_message('ConfigFile': ['creation failed, a file ' \
+          'exists in that path'])
+        return
+      end
+
+      raise e.message
+    end
+
+    # Helps output the error message from the class
+    #
+    # @param msg [Hash] fields from fenton public classes
+    # @return [String] changed hash fields to string for command line output
+    def save_message(msg = {})
+      self.message ||= ''
+
+      msg.each do |key, value|
+        self.message << "#{key.capitalize} #{value.first}\n"
+      end
+    end
+  end
+end

data/lib/fenton_shell/key.rb

@@ -0,0 +1,71 @@
+module FentonShell
+  # Provides SSH Key generation on the local client
+  class Key
+    # @!attribute [r] message
+    #   @return [String] success or failure message and why
+    attr_accessor :message
+
+    # Creates a new key on the local client
+    #
+    # @param options [Hash] fields to send to ssh key pair generation
+    # @return [String] success or failure message
+
+    def create(options)
+      status, body = key_create(options)
+
+      if status
+        save_message('Key': ['created!'])
+        true
+      else
+        save_message(body)
+        false
+      end
+    end
+
+    private
+
+    # Sends a post request with json from the command line key
+    #
+    # @param options [Hash] fields from fenton command line
+    # @return [Object] true or false
+    # @return [String] message on success or failure
+    def key_create(options)
+      ssh_key = key_generation(options)
+      ssh_private_key_file = options[:private_key]
+      ssh_public_key_file = "#{ssh_private_key_file}.pub"
+
+      # TODO: - add to .fenton/config file
+      File.write(ssh_private_key_file, ssh_key.private_key)
+      File.chmod(0o600, ssh_private_key_file)
+      File.write(ssh_public_key_file, ssh_key.ssh_public_key)
+      File.chmod(0o600, ssh_public_key_file)
+
+      [true, 'Key': ['creation failed']]
+    end
+
+    # Generates the SSH key pair
+    #
+    # @param options [Hash] fields from fenton command line
+    # @return [String] ssh key pair object created from the options hash
+    def key_generation(options)
+      SSHKey.generate(
+        type: options[:type],
+        bits: options[:bits],
+        comment: 'ssh@fenton_shell',
+        passphrase: options[:passphrase]
+      )
+    end
+
+    # Helps output the error message from fenton server
+    #
+    # @param msg [Hash] fields from fenton public classes
+    # @return [String] changed hash fields to string for command line output
+    def save_message(msg = {})
+      self.message ||= ''
+
+      msg.each do |key, value|
+        self.message << "#{key.capitalize} #{value.first}\n"
+      end
+    end
+  end
+end

data/lib/fenton_shell/organization.rb

@@ -0,0 +1,70 @@
+module FentonShell
+  # Interfaces with the organization api on fenton server
+  class Organization
+    # @!attribute [r] message
+    #   @return [String] success or failure message and why
+    attr_accessor :message
+
+    # Creates a new organization on fenton server by sending a post
+    # request with json from the command line to create the organization
+    #
+    # @param global_options [Hash] global command line options
+    # @param options [Hash] json fields to send to fenton server
+    # @return [String] success or failure message
+
+    def create(global_options, options)
+      status, body = organization_create(global_options, options)
+
+      if status == 201
+        save_message('Organization': ['created!'])
+        true
+      else
+        save_message(body)
+        false
+      end
+    end
+
+    private
+
+    # Sends a post request with json from the command line organization
+    #
+    # @param global_options [Hash] global command line options
+    # @param options [Hash] json fields to send to fenton server
+    # @return [Fixnum] http status code
+    # @return [String] message back from fenton server
+    def organization_create(global_options, options)
+      result = Excon.post(
+        "#{global_options[:fenton_server_url]}/organizations.json",
+        body: organization_json(options),
+        headers: { 'Content-Type' => 'application/json' }
+      )
+
+      [result.status, JSON.parse(result.body)]
+    end
+
+    # Formulates the organization json for the post request
+    #
+    # @param options [Hash] fields from fenton command line
+    # @return [String] json created from the options hash
+    def organization_json(options)
+      {
+        organization: {
+          name: options[:name],
+          key: options[:key]
+        }
+      }.to_json
+    end
+
+    # Helps output the error message from fenton server
+    #
+    # @param msg [Hash] fields from fenton public classes
+    # @return [String] changed hash fields to string for command line output
+    def save_message(msg = {})
+      self.message ||= ''
+
+      msg.each do |key, value|
+        self.message << "#{key.capitalize} #{value.first}\n"
+      end
+    end
+  end
+end