vermillion-client 1.0.0

data/lib/client/config.rb

@@ -0,0 +1,58 @@
+module Vermillion
+  # Flag for enabling more verbose output from certain methods
+  DEBUG = false
+
+  class Cfg
+    # Perform first run tasks and create or read config file values
+    def bootstrap!
+      populate_config
+
+      return if valid_config?
+
+      # no config file found, lets create one using the firstrun controller
+      require 'client/controller/firstrun'
+
+      controller = Vermillion::Controller::Firstrun.new
+      controller.default
+
+      populate_config
+    end
+
+    # Returns a hash of all module constants and their values
+    def options
+      keys = Vermillion.constants.select { |name| constant?(name) }
+      hash = {}
+
+      keys.each { |key| hash[key] = Vermillion.const_get(key) }
+      hash
+    end
+
+    # Populates the internal hash which stores any values set in the config file
+    def populate_config
+      file = File.expand_path("~/.vermillion.yml")
+      fmt = Vermillion::Helper.load('formatting')
+
+      @yml = fmt.symbolize(::YAML.load_file(file))
+      self
+    end
+
+    # Get a specific value from the config file data
+    # Params:
+    # +name+:: String/symbol key value
+    def get(name)
+      @yml[name.to_sym]
+    end
+
+    private
+
+    # Check if configuration data exists
+    def valid_config?
+      !@yml.nil?
+    end
+
+    # Checks if string is a constant
+    def constant?(name)
+      name == name.upcase
+    end
+  end
+end

data/lib/client/controller.rb

@@ -0,0 +1,68 @@
+module Vermillion
+  module Controller
+    class Base
+      attr_accessor :config, :request
+
+      # Exit code to indicate everything is ok!
+      OK = 0
+      # Exit code to indicate a force quit (exit) call, meaning the program
+      # quit with an error
+      QUIT = 1
+      # Exit code to indicate that the program exited with a non-zero exit code,
+      # but not one that resulted in a force quit
+      QUIT_SOFT = 2
+
+      # Setup internal variables that will be used in subclasses
+      # Params:
+      # +config+:: Instance of Vermillion::Cfg to enable access to config file
+      # +request+:: Instance of Vermillion::Request, enables access to request
+      #             parameters
+      def initialize(config, request)
+        @config = config
+        @request = request
+
+        pre_exec
+      end
+
+      # Perform pre-run tasks
+      def pre_exec
+        @format = Vermillion::Helper.load('formatting')
+        @network = Vermillion::Helper.load('network')
+        @network.config = @config
+      end
+
+      # Handle the request
+      def exec
+        if @request.param.nil?
+          send(@method.to_sym)
+        else
+          send(@method.to_sym, @request.param)
+        end
+      end
+
+      # Perform post-run cleanup tasks, such as deleting old logs
+      def post_exec
+      end
+
+      # Determines if the command can execute
+      # Params:
+      # +command+:: Symbol containing the command we want to execute
+      def can_exec?(command)
+        # no command was passed, check if controller has a default method
+        if command.nil? && respond_to?(:default)
+          @method = :default
+        elsif respond_to? command
+          # check the controller for the requested method
+          @method = command
+        else
+          raise NoMethodError, "Invalid method: #{command}"
+        end
+      end
+
+      # Default method called by exec if no argument is passed
+      def sample
+        Notify.warning("Method not implemented")
+      end
+    end
+  end
+end

data/lib/client/controller/change.rb

@@ -0,0 +1,26 @@
+module Vermillion
+  module Controller
+    class Change < Controller::Base
+      include Helper::ApiCommunication
+
+      # Prepare to execute the requested method
+      def pre_exec
+        OptionParser.new do |opt|
+          opt.banner = "vermillion change [...-flags]"
+
+          opt.on("-t", "--to=TO", "Branch to change to") { |o| @to = o }
+        end.parse!
+
+        super
+      end
+
+      # Change branches on the selected server
+      # +server+:: Symbol representing the server you want to access
+      # +to+:: Optional symbol, what branch should we change to?
+      def branch(server, to = nil)
+        @to = to || @to
+        send_to_one(server, :change_branch, to: @to)
+      end
+    end
+  end
+end

data/lib/client/controller/create.rb

@@ -0,0 +1,26 @@
+module Vermillion
+  module Controller
+    class Create < Controller::Base
+      include Helper::ApiCommunication
+
+      # Prepare to execute the requested method
+      def pre_exec
+        OptionParser.new do |opt|
+          opt.banner = "vermillion create [...-flags]"
+
+          opt.on("-n", "--name=NAME", "Directory to be created") { |o| @name = o }
+        end.parse!
+
+        super
+      end
+
+      # Create a new project on the requested server
+      # +server+:: Symbol representing the server you want to access
+      # +name+:: Optional symbol, the name of the project
+      def one(server, name = nil)
+        @name = name || @name
+        send_to_one(server, :create, name: @name)
+      end
+    end
+  end
+end

data/lib/client/controller/firstrun.rb

@@ -0,0 +1,30 @@
+module Vermillion
+  module Controller
+    class Firstrun < Controller::Base
+      # Create the configuration file if it does not exist
+      def default
+        if File.exist?(Dir.home + '/.vermillion.yml')
+          Notify.error("Configuration already exists, this is not the first run!  Exiting.", show_time: false)
+        end
+
+        File.open(Dir.home + '/.vermillion.yml', "w") do |f|
+          f.write <<-'CONTENTS'
+servers:
+  -
+    name: dev
+    address: 192.168.0.74
+    https: false
+    key: EDIT_ME
+  -
+    name: local
+    address: localhost:8000
+    https: false
+    key: EDIT_ME
+user:
+  test@example.com
+          CONTENTS
+        end
+      end
+    end
+  end
+end

data/lib/client/controller/status.rb

@@ -0,0 +1,43 @@
+module Vermillion
+  module Controller
+    class Status < Controller::Base
+      # Prints both configuration and server information, returns status code 0
+      def default
+        print_config
+        print_servers
+
+        OK
+      end
+
+      # Print configuration information
+      def config
+        print_config
+      end
+
+      # Print configured server information
+      def servers
+        print_servers
+      end
+
+      private
+
+      # Process and print config values
+      def print_config
+        Notify.info("Configuration values")
+
+        @config.options.each_pair do |key, value|
+          Notify.spit " - #{key}: #{value}"
+        end
+      end
+
+      # Process and print server values
+      def print_servers
+        Notify.info('Sites')
+
+        @config.get(:servers).each do |server|
+          Notify.spit(" - Name: #{server[:name]}, Address: #{server[:address]}, HTTPS: #{server[:https]}")
+        end
+      end
+    end
+  end
+end

data/lib/client/controller/update.rb

@@ -0,0 +1,26 @@
+module Vermillion
+  module Controller
+    class Update < Controller::Base
+      include Helper::ApiCommunication
+
+      # Update all sites in the manifest
+      def all
+        send_to_all(:update)
+      end
+
+      # Update just one server
+      # Params:
+      # +server+:: Symbol representing the server you want to update
+      def one(server)
+        send_to_one(server, :update)
+      end
+
+      # Update the configuration manifest for one server
+      # Params:
+      # +server+:: Symbol representing the server you want to update
+      def config(server)
+        send_to_one(server, :update_config)
+      end
+    end
+  end
+end

data/lib/client/helper.rb

@@ -0,0 +1,21 @@
+module Vermillion
+  module Helper
+    # Loads a helper class
+    # Params:
+    # +klass+:: String representing the class helper subclass you want to load
+    # +args+:: Optional arguments to pass to the class instance
+    def self.load(klass, args = nil)
+      klass_instance = Vermillion::Helper.const_get(klass.capitalize)
+
+      if klass_instance
+        if args.nil?
+          klass_instance.new
+        else
+          klass_instance.new(args)
+        end
+      else
+        Notify.error("Class not found: #{klass.capitalize}")
+      end
+    end
+  end
+end

data/lib/client/helper/apicommunication.rb

@@ -0,0 +1,78 @@
+module Vermillion
+  module Helper
+    module ApiCommunication
+      # Send an HTTP request to one server
+      # Params:
+      # +input+:: The server you want to connect to
+      # +endpoint+:: The REST endpoint you'd like to send a request to
+      # +args+:: Any specific configuration data to send along with the request
+      def send_to_one(input, endpoint, args = {})
+        server, endpoint = setup(input, endpoint, args)
+
+        begin
+          resp = @network.post(endpoint.to_s, server[:key])
+
+          Notify.spit(endpoint.to_s) if DEBUG
+          Notify.spit(resp.body) if DEBUG
+
+          # generic failure for invalid response type
+          raise Errno::ECONNREFUSED if resp["Content-Type"] != "application/json"
+
+          # handle JSON response
+          response_data = @format.symbolize(JSON.parse(resp.body))
+
+          if response_data[:_code] == 200
+            Notify.success("#{server[:name]} (#{server[:address]}) update succeeded")
+          elsif !response_data[:message].nil?
+            # work around a messaging issue with vermillion-server
+            Notify.warning("Error: #{response_data[:message]}")
+          else
+            Notify.warning("#{response_data[:_title]}: #{response_data[:_message]}")
+          end
+        rescue Errno::ECONNREFUSED
+          Notify.warning("Request failed for #{server[:name]} (#{server[:address]})")
+        end
+      end
+
+      # Send HTTP requests to all servers in the local manifest
+      # Params:
+      # +endpoint+:: The REST endpoint you'd like to send a request to
+      # +args+:: Any specific configuration data to send along with the request
+      def send_to_all(endpoint, args = {})
+        @config.get(:servers).each do |server|
+          send_to_one(server[:name], endpoint, args) if server[:name]
+        end
+      end
+
+      private
+
+      # Perform setup tasks in ApiCommuniction.send_to_one
+      # Params:
+      # +input+:: The server you want to connect to
+      # +endpoint+:: The REST endpoint you'd like to send a request to
+      # +args+:: Any specific configuration data to send along with the request
+      def setup(input, endpoint, args = {})
+        server_name = input
+        remote_site = nil
+        server_name, remote_site = input.split('/') if input.to_s.include?('/')
+
+        server = @config.get(:servers).select { |hash| hash[:name].to_sym == server_name.to_sym }.first
+
+        # warn user if the server is not defined
+        return Notify.warning("Server not found: #{server_name}") unless server
+        # warn user if the site does not have a secret key property set
+        return Notify.warning("The server configuration must contain a key property to send requests") unless server[:key]
+        # warn user if the user key is not defined
+        return Notify.warning("The configuration file must contain a user") unless @config.get(:user)
+
+        endpoint = Endpoint.new("/api/#{endpoint}/")
+        endpoint.server = server[:address]
+        endpoint.protocol = server[:https]
+        endpoint.add(:remote, remote_site) if remote_site
+        endpoint.add(:query_string, Utils.to_query_string(args))
+
+        [server, endpoint]
+      end
+    end
+  end
+end

data/lib/client/helper/endpoint.rb

@@ -0,0 +1,61 @@
+module Vermillion
+  module Helper
+    class Endpoint
+      attr_writer :server
+
+      # Creates the Endpoint object with default values for internal variables
+      # Params:
+      # +initial_path+:: Starting point of the URL this class will build
+      def initialize(initial_path)
+        @path = { default: initial_path }
+        @server = nil
+        @protocol = "http://"
+      end
+
+      # Set endpoint protocol
+      # Params:
+      # +use_https+:: Boolean value for whether to use HTTPS
+      def protocol=(use_https)
+        @protocol = 'https://' if use_https
+      end
+
+      # Add a section to the path
+      # Params:
+      # +key+:: Symbol, the key to identify the section
+      # +value+:: Any value to store with the associated key
+      def add(key, value)
+        @path[key.to_sym] = value
+      end
+
+      # Return a value based on the provided key
+      # Params:
+      # +key+:: Symbol, the key to identify the section
+      def get(key)
+        @path[key.to_sym]
+      end
+
+      # Deletes a value from the internal hash based on a key
+      # Params:
+      # +key+:: Symbol, the key to identify the section
+      def delete(key)
+        @path.delete(key)
+      end
+
+      # Checks whether a key exists
+      # Params:
+      # +key+:: Symbol, the key to identify the section
+      def exists?(key)
+        @path.key? key
+      end
+
+      # Override the to_s method to return an endpoint fragment
+      def to_s
+        output = @protocol + @server
+        @path.each_pair do |_k, value|
+          output += value
+        end
+        output
+      end
+    end
+  end
+end