class Egnyte::Session

Attributes

access_token[R]
api[RW]
domain[RW]
username[RW]

Public Class Methods

new(opts, strategy=:implicit, backoff=0.5) click to toggle source
# File lib/egnyte/session.rb, line 9
def initialize(opts, strategy=:implicit, backoff=0.5)

  @strategy = strategy # the authentication strategy to use.
  raise Egnyte::UnsupportedAuthStrategy unless [:implicit, :password].include? @strategy

  @backoff = backoff # only two requests are allowed a second by Egnyte.
  @api = 'pubapi' # currently we only support the public API.

  @username = opts[:username]

  # the domain of the egnyte account to interact with.
  raise Egnyte::DomainRequired unless @domain = opts[:domain]

  @client = OAuth2::Client.new(opts[:key], nil, {
    :site => "https://#{@domain}.#{EGNYTE_DOMAIN}",
    :authorize_url => "/puboauth/token",
    :token_url => "/puboauth/token"
  })

  if @strategy == :implicit
    @access_token = OAuth2::AccessToken.new(@client, opts[:access_token]) if opts[:access_token]
  elsif @strategy == :password
    if opts[:access_token]
      @access_token = OAuth2::AccessToken.new(@client, opts[:access_token])
    else
      raise Egnyte::OAuthUsernameRequired unless @username
      raise Egnyte::OAuthPasswordRequired unless opts[:password]
      if true #OS.windows?
        body = {
          :client_id => opts[:key],
          :username => @username,
          :password => opts[:password],
          :grant_type => 'password'
        }.map {|k,v| "#{k}=#{v}"}.join("&")
        url = "https://#{@domain}.#{EGNYTE_DOMAIN}/puboauth/token"
        response = login_post(url, body, return_parsed_response=true)
        @access_token = OAuth2::AccessToken.new(@client, response["access_token"])
      else
        @access_token = @client.password.get_token(@username, opts[:password])
      end
    end
    @username = info["username"] unless @username
  end
  
end

Public Instance Methods

authorize_url(redirect_uri) click to toggle source
# File lib/egnyte/session.rb, line 63
def authorize_url(redirect_uri)
  @client.implicit.authorize_url(:redirect_uri => redirect_uri)
end
create_access_token(token) click to toggle source
# File lib/egnyte/session.rb, line 67
def create_access_token(token)
  @access_token = OAuth2::AccessToken.new(@client, token) if @strategy == :implicit
end
delete(url, return_parsed_response=true) click to toggle source
# File lib/egnyte/session.rb, line 77
def delete(url, return_parsed_response=true)
  uri = URI.parse(Egnyte::Helper.encode_url(url))
  request = Net::HTTP::Delete.new( uri.request_uri )
  resp = request( uri, request, return_parsed_response )
end
get(url, return_parsed_response=true) click to toggle source
# File lib/egnyte/session.rb, line 71
def get(url, return_parsed_response=true)
  uri = URI.parse(Egnyte::Helper.encode_url(url))
  request = Net::HTTP::Get.new( uri.request_uri )
  resp = request( uri, request, return_parsed_response )
end
info() click to toggle source
# File lib/egnyte/session.rb, line 55
def info
  information
end
information() click to toggle source
# File lib/egnyte/session.rb, line 59
def information
  get("https://#{@domain}.#{EGNYTE_DOMAIN}/#{@api}/v1/userinfo", return_parsed_response=true)
end
login_post(url, body, return_parsed_response=true) click to toggle source
# File lib/egnyte/session.rb, line 91
def login_post(url, body, return_parsed_response=true)
  uri = URI.parse(Egnyte::Helper.encode_url(url))
  request = Net::HTTP::Post.new(uri.request_uri)
  request.body = body
  request.content_type = "application/x-www-form-urlencoded"
  resp = request(uri, request, return_parsed_response)
end
multipart_post(url, filename, data, return_parsed_response=true) click to toggle source
# File lib/egnyte/session.rb, line 115
def multipart_post(url, filename, data, return_parsed_response=true)
  uri = URI.parse(Egnyte::Helper.encode_url(url))

  request = Net::HTTP::Post.new(uri.request_uri)
  request.body = data.read
  request.content_type = 'application/binary'

  resp = request(uri, request, return_parsed_response)
end
patch(url, body, return_parsed_response=true) click to toggle source
# File lib/egnyte/session.rb, line 99
def patch(url, body, return_parsed_response=true)
  uri = URI.parse(Egnyte::Helper.encode_url(url))
  request = Net::HTTP::Patch.new(uri.request_uri)
  request.body = body
  request.content_type = "application/json"
  resp = request(uri, request, return_parsed_response)
end
post(url, body, return_parsed_response=true) click to toggle source
# File lib/egnyte/session.rb, line 83
def post(url, body, return_parsed_response=true)
  uri = URI.parse(Egnyte::Helper.encode_url(url))
  request = Net::HTTP::Post.new(uri.request_uri)
  request.body = body
  request.content_type = "application/json"
  resp = request(uri, request, return_parsed_response)
end
put(url, body, return_parsed_response=true) click to toggle source
# File lib/egnyte/session.rb, line 107
def put(url, body, return_parsed_response=true)
  uri = URI.parse(Egnyte::Helper.encode_url(url))
  request = Net::HTTP::Put.new(uri.request_uri)
  request.body = body
  request.content_type = "application/json"
  resp = request(uri, request, return_parsed_response)
end
streaming_download(url, opts) click to toggle source

perform a streaming download of a file rather than in-memory.

# File lib/egnyte/session.rb, line 127
def streaming_download(url, opts)
  uri = URI.parse(Egnyte::Helper.encode_url(url))

  params = {
    :content_length_proc => opts[:content_length_proc],
    :progress_proc => opts[:progress_proc],
    'Authorization' => "Bearer #{@access_token.token}"
  }

  open(uri, params)
end

Private Instance Methods

parse_response_body(body) click to toggle source
# File lib/egnyte/session.rb, line 190
def parse_response_body(body)
  JSON.parse(body)
rescue
  {}
end
parse_response_code(status, response) click to toggle source
# File lib/egnyte/session.rb, line 170
def parse_response_code(status, response)
  case status
  when 400
    raise BadRequest.new(response)
  when 401
    raise NotAuthorized.new(response)
  when 403
    raise InsufficientPermissions.new(response)
  when 404
    raise RecordNotFound.new(response)
  when 405
    raise DuplicateRecordExists.new(response)
  when 413
    raise FileSizeExceedsLimit.new(response)
  end

  # Handle all other request errors.
  raise RequestError.new(response) if status >= 400
end
request(uri, request, return_parsed_response=true) click to toggle source
# File lib/egnyte/session.rb, line 141
def request(uri, request, return_parsed_response=true)
  http = Net::HTTP.new(uri.host, uri.port)
  http.use_ssl = true
  if OS.windows? # Use provided certificate on Windows where gem doesn't have access to a cert store.
    http.cert_store = OpenSSL::X509::Store.new
    http.cert_store.set_default_paths
    http.cert_store.add_file("#{::File.dirname(__FILE__)}/../../includes/cacert.pem")
  end
  #http.set_debug_output($stdout)

  unless request.content_type == "application/x-www-form-urlencoded"
    request.add_field('Authorization', "Bearer #{@access_token.token}")
  end

  response = http.request(request)

  # Egnyte throttles requests to
  # two requests per second by default.
  sleep(@backoff)

  # puts "#{response.code.to_i} ||||| #{response.body}"


  return_value = return_parsed_response ? parse_response_body(response.body) : response
  parse_response_code(response.code.to_i, return_value)

  return_value
end