mauth-client 4.0.1

data/examples/Gemfile.lock

@@ -0,0 +1,41 @@
+PATH
+  remote: ..
+  specs:
+    mauth-client (3.1.4)
+      coderay (~> 1.0)
+      dice_bag (>= 0.9, < 2.0)
+      faraday (~> 0.7)
+      faraday_middleware (~> 0.9)
+      rack
+      term-ansicolor (~> 1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    coderay (1.1.1)
+    dice_bag (1.1.1)
+      diff-lcs (~> 1.0)
+      rake
+      thor (~> 0.0)
+    diff-lcs (1.2.5)
+    faraday (0.9.2)
+      multipart-post (>= 1.2, < 3)
+    faraday_middleware (0.10.0)
+      faraday (>= 0.7.4, < 0.10)
+    multipart-post (2.0.0)
+    rack (2.0.1)
+    rake (11.2.2)
+    term-ansicolor (1.3.2)
+      tins (~> 1.0)
+    thor (0.19.1)
+    tins (1.11.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  faraday (~> 0.9.0)
+  mauth-client!
+
+BUNDLED WITH
+   1.12.5

data/examples/README.md

@@ -0,0 +1,33 @@
+# Examples
+
+## Configuration
+
+After obtaining valid credentials you need to edit the `config.yml` file and set the `app_uuid` accordingly.
+You also need to provide a mauth key and put it in the `mauth_key` file.
+See [the mauth config file doc](../doc/mauth.yml.md) for more information.
+
+This folder contains its own Gemfile and Gemfile.lock files to manage dependencies so you need to run
+```
+bundle install
+```
+before trying any of the scripts.
+
+
+## Fetching a given user's info
+
+Simply run the provided shell script by passing an user's UUID, for instance:
+```
+./get_user_info.rb 4735d013-8d78-4980-8846-fbecf0db0b8e
+```
+
+This should print the user's info, something along the lines of:
+```
+{
+  "user": {
+    "login": "name",
+    "email": "the.email.address@example.com",
+    "uuid": "4735d013-8d78-4980-8846-fbecf0db0b8e",
+    ...
+  }
+}
+```

data/examples/config.yml

@@ -0,0 +1,8 @@
+imedidata:
+  host: https://innovate.imedidata.com
+
+mauth:
+  mauth_baseurl: https://mauth-innovate.imedidata.com
+  mauth_api_version: v1
+  app_uuid: <APP UUID>
+  private_key_file: ./mauth_key

data/examples/get_user_info.rb

@@ -0,0 +1,58 @@
+#!/usr/bin/env ruby
+
+abort "USAGE: ./#{__FILE__} <USER UUID>" unless ARGV.size == 1
+
+require 'bundler/setup'
+Bundler.require(:default)
+
+def config
+  @conf ||= YAML.load(File.open("./config.yml"))
+end
+
+# get user information
+def get_user_info_mauth(user_uuid)
+  get_data_from_imedidata "users/#{user_uuid}.json"
+end
+
+# fetch data from iMedidata
+def get_data_from_imedidata(resource_name)
+  puts "fetching #{resource_name}..."
+  begin
+    connection = Faraday::Connection.new(url: config["imedidata"]["host"]) do |builder|
+      builder.use MAuth::Faraday::RequestSigner, config["mauth"]
+      builder.adapter Faraday.default_adapter
+    end
+
+    # get the data
+    response = connection.get "/api/v2/#{resource_name}"
+    puts "HTTP #{response.status}"
+
+    # return the user info
+    if response.status == 200
+      result = JSON.parse(response.body)
+      puts JSON.pretty_generate(result)
+      result
+    else
+      puts response.body
+      nil
+    end
+  rescue JSON::ParserError => e
+    puts "Error parsing data from imedidata: #{e.inspect}"
+    puts e.backtrace.join("\n")
+  end
+end
+
+get_user_info_mauth(ARGV[0])
+
+
+### OTHER EXAMPLES
+
+#### get study groups for an user
+def get_study_groups_mauth(user_uuid)
+ get_data_from_imedidata "users/#{user_uuid}/study_groups.json"
+end
+
+#### get roles for a user in an application study
+def get_user_study_roles_mauth(user_uuid, study_uuid)
+ get_data_from_imedidata "users/#{user_uuid}/studies/#{study_uuid}/apps/#{config["mauth"]["app_uuid"]}/roles.json"
+end

data/exe/mauth-client

@@ -0,0 +1,264 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.expand_path('../lib', File.dirname(__FILE__))
+
+require 'rubygems'
+require 'faraday'
+require 'faraday_middleware'
+require 'logger'
+require 'mauth/client'
+require 'mauth/faraday'
+require 'yaml'
+require 'term/ansicolor'
+
+# OPTION PARSER 
+
+require 'optparse'
+
+# $options default values
+$options = {
+  :authenticate_response => true,
+  :verbose => true,
+  :color => nil,
+  :no_ssl_verify => false,
+}
+
+additional_headers = []
+opt_parser = OptionParser.new do |opts|
+  opts.banner = "Usage: mauth-client [options] <verb> <url> [body]"
+
+  opts.on("-v", "--[no-]verbose", "Run verbosely - output is like curl -v (this is the default)") do |v|
+    $options[:verbose] = v
+  end
+  opts.on("-q", "Run quietly - only outputs the response body (same as --no-verbose)") do |v|
+    $options[:verbose] = !v
+  end
+  opts.on("--[no-]authenticate", "Authenticate the response received") do |v|
+    $options[:authenticate_response] = v
+  end
+  opts.on("--[no-]color", "Color the output (defaults to color if the output device is a TTY)") do |v|
+    $options[:color] = v
+  end
+  opts.on("-t", "--content-type CONTENT-TYPE", "Sets the Content-Type header of the request") do |v|
+    $options[:content_type] = v
+  end
+  opts.on("-H", "--header LINE", "accepts a json string of additional headers to included. IE 'cache-expirey: 10, other: value") do |v|
+    additional_headers << v
+  end
+  opts.on("--no-ssl-verify", "Disables SSL verification - use cautiously!") do
+    $options[:no_ssl_verify] = true
+  end
+  $options[:additional_headers] =additional_headers
+end
+opt_parser.parse!
+abort(opt_parser.help) unless (2..3).include?(ARGV.size)
+
+# FIND MAUTH CONFIG 
+
+possible_mauth_config_files = [
+  # whoops, I called this MAUTH_CONFIG_YML in one place and MAUTH_CONFIG_YAML in another. supporting both for now. 
+  ENV['MAUTH_CONFIG_YML'],
+  ENV['MAUTH_CONFIG_YAML'],
+  '~/.mauth_config.yml',
+  './config/mauth.yml',
+  './mauth.yml',
+].compact
+
+mauth_config_yml = possible_mauth_config_files.detect do |filename|
+  File.exists?(File.expand_path(filename))
+end
+unless mauth_config_yml
+  message = "could not find mauth config. giving up. please place a mauth config in one of the standard places, " +
+    "or point the MAUTH_CONFIG_YML environment variable at an existing one. standard places are:" +
+    possible_mauth_config_files.map{|f| "\n\t#{f}" }.join
+  abort message
+end
+
+mauth_config = MAuth::Client.default_config(:mauth_config_yml => File.expand_path(mauth_config_yml))
+
+# INSTANTIATE MAUTH CLIENT 
+
+logger = Logger.new(STDERR)
+mauth_client = MAuth::Client.new(mauth_config.merge('logger' => logger))
+
+# OUTPUTTERS FOR FARADAY THAT SHOULD MOVE TO A LIB SOMEWHERE 
+
+# outputs the response body to the given output device (defaulting to STDOUT) 
+class FaradayOutputter < Faraday::Middleware
+  def initialize(app, outdev=STDOUT)
+    @app=app
+    @outdev = outdev
+  end
+
+  def call(request_env)
+    @app.call(request_env).on_complete do |response_env|
+      @outdev.puts(response_env[:body] || '')
+    end
+  end
+end
+
+# this is to approximate `curl -v`s output. but it's all faked, whereas curl gives you 
+# the real text written and read for request and response. whatever, close enough. 
+class FaradayCurlVOutputter < FaradayOutputter
+
+  # defines a method with the given name, applying coloring defined by any additional arguments. 
+  # if $options[:color] is set, respects that; otherwise, applies color if the output device is a tty. 
+  def self.color(name, *color_args)
+    define_method(name) do |arg|
+      if color?
+        color_args.inject(arg) do |result, color_arg|
+          Term::ANSIColor.send(color_arg, result)
+        end
+      else
+        arg
+      end
+    end
+  end
+
+  color :info, :intense_yellow
+  color :info_body, :yellow
+  color :protocol
+
+  color :request, :intense_cyan
+  color :request_verb, :bold
+  color :request_header
+  color :request_blankline, :intense_cyan, :bold
+
+  color :response, :intense_green
+  color :response_status, :bold, :green
+  color :response_header
+  color :response_blankline, :intense_green, :bold
+
+  def call(request_env)
+    @outdev.puts "#{info('*')} #{info_body("connect to #{request_env[:url].host} on port #{request_env[:url].port}")}"
+    @outdev.puts "#{info('*')} #{info_body("getting our SSL on")}" if request_env[:url].scheme=='https'
+    @outdev.puts "#{request('>')} #{request_verb(request_env[:method].to_s.upcase)} #{request_env[:url].path} #{protocol('HTTP/1.1' || 'or something - TODO')}"
+    request_env[:request_headers].each do |k, v|
+      @outdev.puts "#{request('>')} #{request_header(k)}#{request(':')} #{v}"
+    end
+    @outdev.puts "#{request_blankline('>')} "
+    request_body = color_body_by_content_type(request_env[:body], request_env[:request_headers]['Content-Type'])
+    (request_body || '').split("\n", -1).each do |line|
+      @outdev.puts "#{request('>')} #{line}"
+    end
+    @app.call(request_env).on_complete do |response_env|
+      @outdev.puts "#{response('<')} #{protocol('HTTP/1.1' || 'or something - TODO')} #{response_status(response_env[:status].to_s)}"
+      request_env[:response_headers].each do |k, v|
+        @outdev.puts "#{response('<')} #{response_header(k)}#{response(':')} #{v}"
+      end
+      @outdev.puts "#{response_blankline  ('<')} "
+      response_body = color_body_by_content_type(response_env[:body], response_env[:response_headers]['Content-Type'])
+      (response_body || '').split("\n", -1).each do |line|
+        @outdev.puts "#{response('<')} #{line}"
+      end
+    end
+  end
+
+  # whether to use color
+  def color?
+    $options[:color].nil? ? @outdev.tty? : $options[:color]
+  end
+
+  # a mapping for each registered CodeRay scanner to the Media Types which represent 
+  # that language. extremely incomplete! 
+  CodeRayForMediaTypes = {
+    :c => [],
+    :cpp => [],
+    :clojure => [],
+    :css => ['text/css', 'application/css-stylesheet'],
+    :delphi => [],
+    :diff => [],
+    :erb => [],
+    :groovy => [],
+    :haml => [],
+    :html => ['text/html'],
+    :java => [],
+    :java_script => ['application/javascript', 'text/javascript', 'application/x-javascript'],
+    :json => ['application/json', %r(\Aapplication/.*\+json\z)],
+    :php => [],
+    :python => ['text/x-python'],
+    :ruby => [],
+    :sql => [],
+    :xml => ['text/xml', 'application/xml', %r(\Aapplication/.*\+xml\z)],
+    :yaml => [],
+  }
+
+  # takes a body and a content type; returns the body, with coloring (ansi colors for terminals)
+  # possibly added, if it's a recognized content type and #color? is true 
+  def color_body_by_content_type(body, content_type)
+    if body && color?
+      # kinda hacky way to get the media_type. faraday should supply this ...
+      require 'rack'
+      media_type = ::Rack::Request.new({'CONTENT_TYPE' => content_type}).media_type
+      coderay_scanner = CodeRayForMediaTypes.reject{|k,v| !v.any?{|type| type === media_type} }.keys.first
+      if coderay_scanner
+        require 'coderay'
+        if coderay_scanner == :json
+          body = begin
+            JSON.pretty_generate(JSON.parse(body))
+          rescue JSON::ParserError
+            body
+          end
+        end
+        body = CodeRay.scan(body, coderay_scanner).encode(:terminal)
+      end
+    end
+    body
+  end
+end
+
+# CONFIGURE THE FARADAY CONNECTION 
+faraday_options = {}
+if $options[:no_ssl_verify]
+  faraday_options[:ssl] = {:verify => false}
+end
+connection = Faraday.new(faraday_options) do |builder|
+  builder.use MAuth::Faraday::MAuthClientUserAgent, "MAuth-Client CLI"
+  builder.use MAuth::Faraday::RequestSigner, :mauth_client => mauth_client
+  if $options[:authenticate_response]
+    builder.use MAuth::Faraday::ResponseAuthenticator, :mauth_client => mauth_client
+  end
+  builder.use $options[:verbose] ? FaradayCurlVOutputter : FaradayOutputter
+  builder.adapter Faraday.default_adapter
+end
+
+httpmethod, url, body = *ARGV
+
+unless Faraday::Connection::METHODS.map{|m| m.to_s.downcase }.include?(httpmethod.downcase)
+  abort "Unrecognized HTTP method given: #{httpmethod}\n\n" + opt_parser.help
+end
+
+headers = {}
+if $options[:content_type]
+  headers['Content-Type'] = $options[:content_type]
+else
+  if body
+    # I'd rather not have a default content-type, but if none is set then the HTTP adapter sets this to 
+    # application/x-www-form-urlencoded anyway. application/json is a better default for our purposes. 
+    headers['Content-Type'] = 'application/json'
+  end
+end
+
+if $options[:additional_headers]
+  $options[:additional_headers].each do |cur|
+    raise "Headers must be in the format of [key]:[value]" unless cur.include?(':')
+    key, throw_away ,value = cur.partition(':')
+    headers[key] = value
+  end
+end
+
+# OH LOOK IT'S FINALLY ACTUALLY CONNECTING TO SOMETHING
+
+begin
+  response = connection.run_request(httpmethod.downcase.to_sym, url, body, headers)
+rescue MAuth::InauthenticError, MAuth::UnableToAuthenticateError => e
+  if $options[:color].nil? ? STDERR.tty? : $options[:color]
+    class_color = Term::ANSIColor.method(e.is_a?(MAuth::InauthenticError) ? :intense_red : :intense_yellow)
+    message_color = Term::ANSIColor.method(e.is_a?(MAuth::InauthenticError) ? :red : :yellow)
+  else
+    class_color = proc{|s| s }
+    message_color = proc{|s| s }
+  end
+  STDERR.puts(class_color.call(e.class.to_s))
+  STDERR.puts(message_color.call(e.message))
+end

data/exe/mauth-proxy

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.expand_path('../lib', File.dirname(__FILE__))
+
+require 'rubygems'
+require 'mauth/proxy'
+require 'rack'
+
+headers = []
+headers_index = ARGV.find_index('--header')
+while(headers_index) do
+  headers << ARGV[headers_index + 1]
+  ARGV.delete_at(headers_index + 1)
+  ARGV.delete_at(headers_index)
+  headers_index = ARGV.find_index('--header')
+end
+
+authenticate_responses = !ARGV.delete('--no-authenticate')
+browser_proxy = !(ARGV.delete('--browser_proxy').nil?)
+
+target_uri = browser_proxy ? ARGV : ARGV.pop
+
+if !target_uri || target_uri.empty?
+  abort("Usage: mauth-proxy [rack options] --browser_proxy [--no-authenticate] <target URI> <target URI> ...\n" +
+    "or: mauth-proxy [rack options] <target URI>")
+end
+
+rack_server_options = Rack::Server::Options.new.parse!(ARGV)
+
+# for security, this rack server will only accept local connections, so override Host 
+# to 127.0.0.1 (from the default of 0.0.0.0)
+#
+# this means that the '-o' / '--host' option to Rack::Server::Options is ignored. 
+rack_server_options[:Host] = "127.0.0.1"
+
+rack_server_options[:app] = MAuth::Proxy.new(target_uri, :authenticate_responses => authenticate_responses,
+  :browser_proxy => browser_proxy, :headers => headers)
+
+mauth_proxy_server = Rack::Server.new(rack_server_options)
+mauth_proxy_server.start

data/lib/mauth/autoload.rb

@@ -0,0 +1,8 @@
+module MAuth
+  autoload :Client, 'mauth/client'
+  autoload :Middleware, 'mauth/middleware'
+  autoload :Faraday, 'mauth/faraday'
+  autoload :Rack, 'mauth/rack'
+  autoload :Request, 'mauth/request_and_response'
+  autoload :Response, 'mauth/request_and_response'
+end