conify 0.0.1

data/lib/conify/command/abstract_command.rb

@@ -0,0 +1,15 @@
+require 'conify/command'
+require 'conify/helpers'
+
+class Conify::Command::AbstractCommand
+  include Conify::Helpers
+
+  attr_reader :args
+  attr_reader :options
+
+  def initialize(args = [], options = {})
+    @args = args
+    @options = options
+  end
+
+end

data/lib/conify/command/global.rb

@@ -0,0 +1,109 @@
+require 'conify/command/abstract_command'
+require 'conify/manifest'
+require 'conify/test/all_test'
+require 'conify/test/manifest_test'
+require 'conify/api/users'
+require 'conify/api/addons'
+
+class Conify::Command::Global < Conify::Command::AbstractCommand
+
+  def init
+    # Error out if conflux-manifest.json already exists
+    if File.exists?(manifest_path)
+      error "Manifest File #{manifest_filename} already exists."
+    else
+      begin
+        # Create new conflux-manifest.json file from template
+        File.open(manifest_path, 'w+') do |f|
+          f.write(Conify::Manifest.template)
+        end
+
+        display([
+          "Created new manifest template at #{manifest_filename}.",
+          "Modify it to your service's specs and then run 'conify test'."
+        ].join("\n"))
+      rescue Exception => e
+        File.delete(manifest_path) # Remove file if something screws up during file creation
+        display "Error initializing conify manifest: #{e.message}"
+      end
+    end
+  end
+
+  def test
+    begin
+      # Get the content from conflux-manifest.json and add the 'env'
+      # key specifying which environment to test.
+      data = manifest_content
+      data['env'] = (@args[0] === '--production') ? 'production' : 'test'
+
+      # Run all tests to ensure Conflux integration is set up correctly
+      Conify::AllTest.new(data).call
+
+      display "Everything checks out!\nRun 'conify push' to push your service to Conflux."
+    rescue Exception => e
+      display e.message
+    end
+  end
+
+  def push
+    # First ensure manifest exists.
+    if !File.exists?(manifest_path)
+      error "No Conflux manifest exists yet.\nRun 'conflux init' to create a new manifest."
+    end
+
+    # Run Manifest Test to ensure file is valid.
+    Conify::ManifestTest.new(manifest_content).call
+
+    # Request Conflux email/password creds.
+    creds = ask_for_conflux_creds
+
+    # Login to Conflux with these creds, returning a valid user-token.
+    auth_resp = Conify::Api::Users.new.login(creds)
+
+    # Push new service to Conflux.
+    push_resp = Conify::Api::Addons.new.push(manifest_content, auth_resp['user_token'])
+
+    display "Successfully pushed draft service to Conflux!\nRun 'conify open' to finish editing your service's information."
+  end
+
+  def open
+    # First ensure manifest exists.
+    if !File.exists?(manifest_path)
+      error "No Conflux manifest exists yet.\nRun 'conflux init' to create a new manifest."
+    end
+
+    service_id = manifest_content['id'] || ''
+    error 'Manifest must have an "id" field.' if service_id.empty?
+
+    edit_service_url = "#{site_url}/services/#{service_id}/edit"
+    display "Opening Conflux Service at: #{edit_service_url}"
+    open_url(edit_service_url)
+  end
+
+  #----------------------------------------------------------------------------
+
+  module CommandInfo
+
+    module Init
+      DESCRIPTION = 'Create a new Conflux manifest'
+      VALID_ARGS = [ [] ]
+    end
+
+    module Test
+      DESCRIPTION = 'Test that your Conflux integration is set up correctly'
+      VALID_ARGS = [ [], ['--production'] ]
+    end
+
+    module Push
+      DESCRIPTION = 'Push your draft service to Conflux'
+      VALID_ARGS = [ [] ]
+    end
+
+    module Open
+      DESCRIPTION = 'Open the url to edit your service on Conflux'
+      VALID_ARGS = [ [] ]
+    end
+
+  end
+
+end

data/lib/conify/helpers.rb

@@ -0,0 +1,223 @@
+module Conify
+  module Helpers
+    extend self
+
+    def error(msg = '')
+      $stderr.puts(format_with_bang(msg))
+      exit(1)
+    end
+
+    # Add a bang to an error message
+    def format_with_bang(message)
+      return message if !message.is_a?(String)
+      return '' if message.to_s.strip == ''
+      " !    " + message.encode('utf-8', 'binary', invalid: :replace, undef: :replace).split("\n").join("\n !    ")
+    end
+
+    def display(msg = '')
+      puts(msg)
+      $stdout.flush
+    end
+
+    # convert string from underscores to camelcase
+    def camelize(str)
+      str.split('_').collect(&:capitalize).join
+    end
+
+    # format some data into a table to then be displayed to the user
+    def to_table(data, headers)
+      column_lengths = []
+      gutter = 2
+      table = ''
+
+      # Figure out column widths based on longest string in each column (including the header string)
+      headers.each { |header|
+        width = data.map { |_| _[header] }.max_by(&:length).length
+
+        width = header.length if width < header.length
+
+        column_lengths << width
+      }
+
+      # format the length of a table cell string to make it as wide as the column (by adding extra spaces)
+      format_row_entry = lambda { |entry, i|
+        entry + (' ' * (column_lengths[i] - entry.length + gutter))
+      }
+
+      # Add headers
+      headers.each_with_index { |header, i|
+        table += format_row_entry.call(header, i)
+      }
+
+      table += "\n"
+
+      # Add line breaks under headers
+      column_lengths.each { |length|
+        table += (('-' * length) + (' ' * gutter))
+      }
+
+      table += "\n"
+
+      # Add rows
+      data.each { |row|
+        headers.each_with_index { |header, i|
+          table += format_row_entry.call(row[header], i)
+        }
+
+        table += "\n"
+      }
+
+      table
+    end
+
+    def allow_user_response
+      $stdin.gets.to_s.strip
+    end
+
+    def running_on_windows?
+      RUBY_PLATFORM =~ /mswin32|mingw32/
+    end
+
+    def running_on_a_mac?
+      RUBY_PLATFORM =~ /-darwin\d/
+    end
+
+    def ask_for_password_on_windows
+      require 'Win32API'
+      char = nil
+      password = ''
+
+      while char = Win32API.new('msvcrt', '_getch', [ ], 'L').Call do
+        break if char == 10 || char == 13 # received carriage return or newline
+        if char == 127 || char == 8 # backspace and delete
+          password.slice!(-1, 1)
+        else
+          # windows might throw a -1 at us so make sure to handle RangeError
+          (password << char.chr) rescue RangeError
+        end
+      end
+
+      puts
+      password
+    end
+
+    def ask_for_password
+      begin
+        echo_off  # make the password input hidden
+        password = allow_user_response
+        puts
+      ensure
+        echo_on  # flip input visibility back on
+      end
+
+      password
+    end
+
+    # Hide user input
+    def echo_off
+      with_tty do
+        system 'stty -echo'
+      end
+    end
+
+    # Show user input
+    def echo_on
+      with_tty do
+        system 'stty echo'
+      end
+    end
+
+    def with_tty(&block)
+      return unless $stdin.isatty
+      begin
+        yield
+      rescue
+        # fails on windows
+      end
+    end
+
+    def ask_for_conflux_creds
+      # Ask for Conflux Credentials
+      puts 'Enter your Conflux credentials.'
+
+      # Email:
+      print 'Email: '
+      email = allow_user_response
+
+      # Password
+      print 'Password (typing will be hidden): '
+
+      password = running_on_windows? ? ask_for_password_on_windows : ask_for_password
+
+      { email: email, password: password }
+    end
+
+    # Strip the protocol + following slashes off of a url
+    def host
+      host_url.gsub(/http:\/\/|https:\/\//, '')
+    end
+
+    def host_url
+      ENV['CONFLUX_HOST'] || 'https://api.goconflux.com'
+    end
+
+    def site_url
+      ENV['CONFLUX_SITE_URL'] || 'https://goconflux.com'
+    end
+
+    # Get an array (of symbols) of the user-defined methods for a klass
+    def manually_added_methods(klass)
+      klass.instance_methods(false)
+    end
+
+    def manifest_path
+      File.join(Dir.pwd, manifest_filename)
+    end
+
+    def manifest_filename
+      'conflux-manifest.json'
+    end
+
+    def manifest_content
+      JSON.parse(File.read(manifest_path)) rescue {}
+    end
+
+    def kensa_manifest_path
+      File.join(Dir.pwd, kensa_manifest_name)
+    end
+
+    def kensa_manifest_name
+      'addon-manifest.json'
+    end
+
+    def exclusive_deep_merge(merge_to, merge_from)
+      merged = merge_to.clone
+
+      merge_from.each do |key, value|
+        # Only override existing key
+        if merged.keys.include?(key)
+          # Deep merge for nested hash
+          if value.is_a?(Hash) && merged[key].is_a?(Hash)
+            merged[key] = exclusive_deep_merge(merged[key], value)
+          else
+            merged[key] = value
+          end
+        end
+      end
+
+      merged
+    end
+
+    def open_url(url)
+      if running_on_a_mac?
+        system "open #{url}"
+      elsif running_on_windows?
+        system "explorer #{url}"
+      else
+        # Probably some flavor of Linux
+        system "xdg-open #{url}"
+      end
+    end
+
+  end
+end

data/lib/conify/http.rb

@@ -0,0 +1,56 @@
+require 'restclient'
+require 'conify/okjson'
+
+# Used for making http requests when testing Conflux compatibility
+module Conify
+  module HTTPForTests
+
+    def get(path, params={})
+      path = "#{path}?" + params.map { |k, v| "#{k}=#{v}" }.join('&') unless params.empty?
+      request(:get, [], path)
+    end
+
+    def post(credentials, path, payload=nil)
+      request(:post, credentials, path, payload)
+    end
+
+    def put(credentials, path, payload=nil)
+      request(:put, credentials, path, payload)
+    end
+
+    def delete(credentials, path, payload=nil)
+      request(:delete, credentials, path, payload)
+    end
+
+    def request(method, credentials, path, payload=nil)
+      code = nil
+      body = nil
+
+      begin
+        args = [{ accept: 'application/json' }]
+
+        if payload
+          args.first[:content_type] = 'application/json'
+          args.unshift(payload.to_json)
+        end
+
+        user, pass = credentials
+        body = RestClient::Resource.new(url, user: user, password: pass, verify_ssl: false)[path].send(
+          method,
+          *args
+        ).to_s
+
+        code = 200
+      rescue RestClient::ExceptionWithResponse => e
+        code = e.http_code
+        body = e.http_body
+      rescue Errno::ECONNREFUSED
+        code = -1
+        body = nil
+      end
+
+      [code, body]
+    end
+
+  end
+end

data/lib/conify/manifest.rb

@@ -0,0 +1,58 @@
+require 'securerandom'
+require 'conify/helpers'
+
+module Conify
+  module Manifest
+    extend self
+    extend Conify::Helpers
+
+    def password_gen(size = 8)
+      SecureRandom.hex(size)
+    end
+
+    def default_port
+      3000
+    end
+
+    def template
+      # Use conflux template as default
+      manifest = JSON.parse(conflux_template)
+
+      # If the kensa manifest exists, return the exclusively merged two manifests.
+      if File.exists?(kensa_manifest_name)
+        kensa_manifest = JSON.parse(File.read(kensa_manifest_path)) rescue {}
+        manifest = exclusive_deep_merge(manifest, kensa_manifest)
+      end
+
+      # Don't copy over password or sso_salt, so just set them now:
+      manifest['api']['password'] = password_gen
+      manifest['api']['sso_salt'] = password_gen
+
+      JSON.pretty_generate(manifest)
+    end
+
+    def conflux_template
+      <<-JSON
+{
+  "id": "myservice",
+  "api": {
+    "config_vars": [
+      "MYSERVICE_URL"
+    ],
+    "password": "",
+    "sso_salt": "",
+    "production": {
+      "base_url": "https://yourapp.com/conflux/resources",
+      "sso_url": "https://yourapp.com/conflux/sso"
+    },
+    "test": {
+      "base_url": "http://localhost:#{default_port}/conflux/resources",
+      "sso_url": "http://localhost:#{default_port}/conflux/sso"
+    }
+  }
+}
+      JSON
+    end
+
+  end
+end