etna 0.1.14 → 0.1.20

data/lib/etna.rb

@@ -15,3 +15,10 @@ require_relative './etna/describe_routes'
 require_relative './etna/client'
 require_relative './etna/symbolize_params'
 require_relative './etna/spec'
+require_relative './etna/clients'
+require_relative './etna/csvs'
+require_relative './etna/environment_scoped'
+
+class EtnaApp
+  include Etna::Application
+end

data/lib/etna/application.rb

@@ -4,17 +4,31 @@
 # whenever we want to use it as a container
 
 require_relative './sign_service'
+require_relative './command'
+require_relative './generate_autocompletion_script'
 require 'singleton'
+require 'rollbar'
 
 module Etna::Application
   def self.included(other)
     other.include Singleton
+    other.include Etna::CommandExecutor
+    @@application = other
+
+    other.const_set(:GenerateCompletionScript, Class.new(Etna::GenerateCompletionScript))
   end
 
   def self.find(klass)
-    Kernel.const_get(
-      klass.name.split('::').first
-    ).instance
+    namespace = klass.name.split('::').first
+    if (namespace_klass = Kernel.const_get(namespace)) && (namespace_klass.respond_to? :instance)
+      return namespace_klass.instance
+    end
+
+    if @@application
+      return @@application.instance
+    end
+
+    raise "Could not find application instance from #{namespace}, and not subclass of Application found."
   end
 
   def self.register(app)
@@ -31,6 +45,12 @@ module Etna::Application
 
   def configure(opts)
     @config = opts
+
+    if (rollbar_config = config(:rollbar)) && rollbar_config[:access_token]
+      Rollbar.configure do |config|
+        config.access_token = rollbar_config[:access_token]
+      end
+    end
   end
 
   def setup_logger
@@ -40,18 +60,27 @@ module Etna::Application
       # Number of old copies of the log to keep.
       config(:log_copies) || 5,
       # How large the log can get before overturning.
-      config(:log_size) || 1048576
+      config(:log_size) || 1048576,
     )
     log_level = (config(:log_level) || 'warn').upcase.to_sym
-
     @logger.level = Logger.const_defined?(log_level) ? Logger.const_get(log_level) : Logger::WARN
   end
 
   # the application logger is available globally
   attr_reader :logger
 
-  def config(type)
-    @config[environment][type]
+  def config(type, env = environment)
+    return nil if @config.nil?
+    return nil if @config[env].nil?
+    return nil unless @config[env].is_a?(Hash)
+    @config[env][type]
+  end
+
+  def env_config(env = environment)
+    return nil if @config.nil?
+    return nil if @config[env].nil?
+    return nil unless @config[env].is_a?(Hash)
+    @config[env]
   end
 
   def sign
@@ -68,23 +97,18 @@ module Etna::Application
     end
   end
 
-  def run_command(config, cmd = :help, *args)
-    cmd = cmd.to_sym
-    if commands.key?(cmd)
-      commands[cmd].setup(config)
-      commands[cmd].execute(*args)
-    else
-      commands[:help].execute
+  def run_command(config, *args, &block)
+    cmd, cmd_args, cmd_kwds = find_command(*args)
+    cmd.setup(config)
+
+    if block_given?
+      return unless yield [cmd, cmd_args]
     end
-  end
 
-  def commands
-    @commands ||= Hash[
-      find_descendents(Etna::Command).map do |c|
-        cmd = c.new
-        [ cmd.name, cmd ]
-      end
-    ]
+    cmd.execute(*cmd.fill_in_missing_params(cmd_args), **cmd_kwds)
+  rescue => e
+    Rollbar.error(e)
+    raise
   end
 end
 

data/lib/etna/client.rb

@@ -1,16 +1,20 @@
 require 'net/http/persistent'
 require 'net/http/post/multipart'
 require 'singleton'
+require 'rack/utils'
 
 module Etna
   class Client
-    def initialize(host, token)
-      @host = host.sub(%r!/$!,'')
+    def initialize(host, token, routes_available: true, persistent: true, ignore_ssl: false)
+      @host = host.sub(%r!/$!, '')
       @token = token
+      @persistent = persistent
+      @ignore_ssl = ignore_ssl
 
-      set_routes
-
-      define_route_helpers
+      if routes_available
+        set_routes
+        define_route_helpers
+      end
     end
 
     attr_reader :routes
@@ -19,6 +23,29 @@ module Etna
       Etna::Route.path(route[:route], params)
     end
 
+    def multipart_post(endpoint, content, &block)
+      uri = request_uri(endpoint)
+      multipart = Net::HTTP::Post::Multipart.new uri.request_uri, content
+      multipart.add_field('Authorization', "Etna #{@token}")
+      request(uri, multipart, &block)
+    end
+
+    def post(endpoint, params = {}, &block)
+      body_request(Net::HTTP::Post, endpoint, params, &block)
+    end
+
+    def get(endpoint, params = {}, &block)
+      query_request(Net::HTTP::Get, endpoint, params, &block)
+    end
+
+    def options(endpoint, params = {}, &block)
+      query_request(Net::HTTP::Options, endpoint, params, &block)
+    end
+
+    def delete(endpoint, params = {}, &block)
+      body_request(Net::HTTP::Delete, endpoint, params, &block)
+    end
+
     private
 
     def set_routes
@@ -30,12 +57,12 @@ module Etna
     def define_route_helpers
       @routes.each do |route|
         next unless route[:name]
-        self.define_singleton_method(route[:name]) do |params={}|
+        self.define_singleton_method(route[:name]) do |params = {}|
 
           missing_params = (route[:params] - params.keys.map(&:to_s))
           unless missing_params.empty?
             raise ArgumentError, "Missing required #{missing_params.size > 1 ?
-              'params' : 'param'} #{missing_params.join(', ')}"
+                'params' : 'param'} #{missing_params.join(', ')}"
           end
 
           response = send(route[:method].downcase, route_path(route, params), params)
@@ -54,45 +81,29 @@ module Etna
 
     def persistent_connection
       @http ||= begin
-                  http = Net::HTTP::Persistent.new
-                  http.read_timeout = 3600
-                  http
-                end
-    end
-
-    def multipart_post(endpoint, content, &block)
-      uri = request_uri(endpoint)
-      multipart = Net::HTTP::Post::Multipart.new uri.path, content
-      multipart.add_field('Authorization', "Etna #{@token}")
-      request(uri, multipart, &block)
-    end
-
-    def post(endpoint, params={}, &block)
-      body_request(Net::HTTP::Post, endpoint, params, &block)
-    end
-
-    def get(endpoint, params={}, &block)
-      query_request(Net::HTTP::Get, endpoint, params, &block)
-    end
-
-    def options(endpoint, params={}, &block)
-      query_request(Net::HTTP::Options, endpoint, params, &block)
+        http = Net::HTTP::Persistent.new
+        http.read_timeout = 3600
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE if @ignore_ssl
+        http
+      end
     end
 
-    def delete(endpoint, params={}, &block)
-      body_request(Net::HTTP::Delete, endpoint, params, &block)
-    end
 
-    def body_request(type, endpoint, params={}, &block)
+    def body_request(type, endpoint, params = {}, &block)
       uri = request_uri(endpoint)
-      req = type.new(uri.request_uri,request_params)
+      req = type.new(uri.request_uri, request_params)
       req.body = params.to_json
       request(uri, req, &block)
     end
 
-    def query_request(type, endpoint, params={}, &block)
+    def query_request(type, endpoint, params = {}, &block)
       uri = request_uri(endpoint)
-      uri.query = URI.encode_www_form(params)
+
+      if uri.query
+        uri.query += "&" + URI.encode_www_form(params)
+      else
+        uri.query = URI.encode_www_form(params)
+      end
       req = type.new(uri.request_uri, request_params)
       request(uri, req, &block)
     end
@@ -103,9 +114,9 @@ module Etna
 
     def request_params
       {
-        'Content-Type' => 'application/json',
-        'Accept'=> 'application/json, text/*',
-        'Authorization'=>"Etna #{@token}"
+          'Content-Type' => 'application/json',
+          'Accept' => 'application/json, text/*',
+          'Authorization' => "Etna #{@token}"
       }
     end
 
@@ -113,8 +124,8 @@ module Etna
       status = response.code.to_i
       if status >= 400
         msg = response.content_type == 'application/json' ?
-          json_error(response.body) :
-          response.body
+            json_error(response.body) :
+            response.body
         raise Etna::Error.new(msg, status)
       end
     end
@@ -130,14 +141,37 @@ module Etna
 
     def request(uri, data)
       if block_given?
-        persistent_connection.request(uri, data) do |response|
-          status_check!(response)
-          yield response
+        if @persistent
+          persistent_connection.request(uri, data) do |response|
+            status_check!(response)
+            yield response
+          end
+        else
+          verify_mode = @ignore_ssl ?
+            OpenSSL::SSL::VERIFY_NONE :
+            OpenSSL::SSL::VERIFY_PEER
+          Net::HTTP.start(uri.host, uri.port, use_ssl: true, verify_mode: verify_mode) do |http|
+            http.request(data) do |response|
+              status_check!(response)
+              yield response
+            end
+          end
         end
       else
-        response = persistent_connection.request(uri, data)
-        status_check!(response)
-        return response
+        if @persistent
+          response = persistent_connection.request(uri, data)
+          status_check!(response)
+          return response
+        else
+          verify_mode = @ignore_ssl ?
+            OpenSSL::SSL::VERIFY_NONE :
+            OpenSSL::SSL::VERIFY_PEER
+          Net::HTTP.start(uri.host, uri.port, use_ssl: true, verify_mode: verify_mode) do |http|
+            response = http.request(data)
+            status_check!(response)
+            return response
+          end
+        end
       end
     end
   end

data/lib/etna/clients.rb

@@ -0,0 +1,4 @@
+require_relative 'clients/magma'
+require_relative 'clients/metis'
+require_relative 'clients/janus'
+require_relative 'clients/polyphemus'

data/lib/etna/clients/enum.rb

@@ -0,0 +1,9 @@
+module Enum
+  def self.included(cls)
+    cls.instance_eval do
+      def entries
+        self.constants.map { |c| self.const_get(c) }.select { |v| v.instance_of?(self) }
+      end
+    end
+  end
+end

data/lib/etna/clients/janus.rb

@@ -0,0 +1,2 @@
+require_relative './janus/client'
+require_relative './janus/models'

data/lib/etna/clients/janus/client.rb

@@ -0,0 +1,73 @@
+require 'net/http/persistent'
+require 'net/http/post/multipart'
+require 'singleton'
+require_relative '../../client'
+require_relative './models'
+
+module Etna
+  module Clients
+    class Janus
+      def initialize(host:, token:, persistent: true, ignore_ssl: false)
+        raise 'Janus client configuration is missing host.' unless host
+        raise 'Janus client configuration is missing token.' unless token
+        @etna_client = ::Etna::Client.new(
+          host,
+          token,
+          routes_available: false,
+          persistent: persistent,
+          ignore_ssl: ignore_ssl)
+      end
+
+      def get_project(get_project_request = GetProjectRequest.new)
+        html = nil
+        @etna_client.get(
+          "/project/#{get_project_request.project_name}",
+          get_project_request) do |res|
+          html = res.body
+        end
+
+        HtmlResponse.new(html)
+      end
+
+      def add_project(add_project_request = AddProjectRequest.new)
+        @etna_client.post('/add_project', add_project_request) do |res|
+          # Redirect, no response data
+        end
+      end
+
+      def add_user(add_user_request = AddUserRequest.new)
+        @etna_client.post(
+          "/add_user/#{add_user_request.project_name}",
+          add_user_request) do |res|
+          # Redirect, no response data
+        end
+      end
+
+      def update_permission(update_permission_request = UpdatePermissionRequest.new)
+        @etna_client.post(
+          "/update_permission/#{update_permission_request.project_name}",
+          update_permission_request) do |res|
+          # Redirect, no response data
+        end
+      end
+
+      def refresh_token(refresh_token_request = RefreshTokenRequest.new)
+        token = nil
+        @etna_client.get('/refresh_token', refresh_token_request) do |res|
+          token = res.body
+        end
+
+        TokenResponse.new(token)
+      end
+
+      def viewer_token(viewer_token_request = ViewerTokenRequest.new)
+        token = nil
+        @etna_client.get('/viewer_token', viewer_token_request) do |res|
+          token = res.body
+        end
+
+        TokenResponse.new(token)
+      end
+    end
+  end
+end

data/lib/etna/clients/janus/models.rb

@@ -0,0 +1,78 @@
+require 'ostruct'
+require_relative '../../json_serializable_struct'
+
+# TODO:  In the near future, I'd like to transition to specifying apis via SWAGGER and generating model stubs from the
+# common definitions.  For nowe I've written them out by hand here.
+module Etna
+  module Clients
+    class Janus
+      class GetProjectRequest < Struct.new(:project_name, keyword_init: true)
+        include JsonSerializableStruct
+
+        def initialize(**params)
+          super({}.update(params))
+        end
+      end
+
+      class AddProjectRequest < Struct.new(:project_name, :project_name_full, keyword_init: true)
+        include JsonSerializableStruct
+
+        def initialize(**params)
+          super({}.update(params))
+        end
+      end
+
+      class AddUserRequest < Struct.new(:project_name, :email, :name, :role, :privileged, :affiliation, keyword_init: true)
+        include JsonSerializableStruct
+
+        def initialize(**params)
+          super({privileged: false, affiliation: ''}.update(params))
+        end
+      end
+
+      class UpdatePermissionRequest < Struct.new(:project_name, :email, :role, :privileged, :affiliation, keyword_init: true)
+        include JsonSerializableStruct
+
+        def initialize(**params)
+          super({privileged: false, affiliation: ''}.update(params))
+        end
+      end
+
+      class RefreshTokenRequest
+        def map
+          []
+        end
+      end
+
+      class ViewerTokenRequest
+        def map
+          []
+        end
+      end
+
+      class HtmlResponse
+        attr_reader :raw
+
+        def initialize(raw = '')
+          @raw = raw
+        end
+
+        def html
+          @raw
+        end
+      end
+
+      class TokenResponse
+        attr_reader :raw
+
+        def initialize(raw = '')
+          @raw = raw
+        end
+
+        def token
+          @raw
+        end
+      end
+    end
+  end
+end