rubyment 0.6.25510166 → 0.6.25520442

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 086bfae4056987bcb9407aef1bfe78b96aced53d
-  data.tar.gz: 6230971e4d613af63253a9d2e78c6f1614914ddb
+  metadata.gz: cce36ba8078584171153cda12ca7047f3d200432
+  data.tar.gz: d5a3ac0260a86b0777233502f000f2fa346a5538
 SHA512:
-  metadata.gz: 35f4f45bddc27547ec7fd80372fa69fa452c9592308bf86d4a77debfb3eda56e0b761aaaa21fa07a4203f5f4c868ab531e54ad6cf3723b8781a347a2707e1797
-  data.tar.gz: 15d9d7b9f0608ea360a8c1ef743b4b6f0a8b90fed75978d25117dc7a48ce539a050a8c40290ae93c1d2f991bf2eabedfa388346b5565e96aafed33c67828f20c
+  metadata.gz: 2ad63e004ceb35092d1bb56df6a7b4d832c94e6f164f759b4b8955ac345c43cdc4e59c644a7e6230c27618ae75f3e9dd6d460db0864380d440307d3fca013994
+  data.tar.gz: 483f0e5096aa5bbe5044e9e3968110e9f4472f6becc35aa036bd92f6b67782390a07938f948c782103839e89415969fc033ad0d11b56a670a510aa9f5cae0ad4

data/lib/rubyment.rb

@@ -140,21 +140,46 @@ class Rubyment
   # @param [splat] +args+, an splat whose elements are expected to be +blea_args+ and +blocks_args+:
   # +blea_args+:: [Array] args to be used internally, which are expected to be:
   # +exception_admitted+:: [Boolean]
-  # +output_exception+:: [Boolean]
+  # +output_exception+:: [Boolean] note that this only makes sense if exception is admitted -- otherwise an exception will be normally thrown.
+  # +ret_nil_on_exception+:: [Boolean] enforces that +nil+ will be returned on exception
   # +blocks_args+:: [splat] args to be forwarded to the block call
   # @return [Proc]
   def blea *args, &block
     blea_args, *block_args = args
     blea_args ||= blea_args.nne []
-    exception_admitted, output_exception = blea_args
-    exception_admitted ||= exception_admitted.nne
-    output_exception ||=  output_exception.nne
-    ble_method = output_exception && :bloe || :blef
+    exception_admitted, output_exception, ret_nil_on_exception = blea_args
+    exception_admitted = exception_admitted.nne
+    output_exception   =  output_exception.nne
+    bloe_method = ret_nil_on_exception && :bloef || :bloe
+    ble_method = output_exception && bloe_method || :blef
     bl_to_call = exception_admitted && ble_method || :bl
     send bl_to_call, *block_args, &block
   end
 
 
+  # creates a Proc out of a block,
+  # will capture all exceptions
+  # inside that block and ignore it
+  # will return nil
+  def bloef *args, &block
+    block ||= lambda {}
+    bl {
+      begin
+        block.call *args
+      rescue => e
+        stderr = @memory[:stderr]
+        rv = [e.backtrace.join("\n"), e]
+        stderr.puts "#{__method__} exception backtrace:"
+        stderr.puts rv[0]
+        stderr.puts "#{__method__} exception inspection:"
+        stderr.puts rv[1].inspect
+        stderr.puts "#{__method__} exception message:"
+        stderr.puts rv[1]
+      end
+    }
+  end
+
+
   #  runs a block error free
   # (returns nil if exception happens)
   def runef *args, &block
@@ -209,6 +234,9 @@ class Rubyment
   # in this right moment it is not
   # yet possible to return the exception
   # without printing (planned improvement)
+  # another desirable case is to output
+  # the exception, but don't return it;
+  # not yet possible.
   # @param [splat] +args+, an splat whose elements are expected to be +blea_args+ and +blocks_args+:
   # +blea_args+:: [Array] args to be used internally, which are expected to be:
   # +exception_admitted+:: [Boolean]
@@ -342,31 +370,56 @@ class Rubyment
   end
 
 
-  # reads a uri (if 'open-uri' available, otherwise, just do a normal File.read)
+  # reads a uri (if 'rest-client' or 'open-uri' available and they don't throw any exception, otherwise, just do a normal File.read)
   # @param [Array] args, an +Array+ whose elements are expected to be:
-  # +uri+:: [String, nil] uri or path of the file
+  # +uri+:: [String, nil] uri or path of the file (empty string is assumed in the case of +nil+ given)
   # +username+:: [String] basic http authentication username
   # +password+:: [String] basic http authentication password
   # +return_on_rescue+:: [Object] a default to return in the case of exceptions raised
   # +return_on_directory_given+:: [Object] a default to return in the case uri is a directory. Defaults to true
+  # +skip_open_uri+:: [Boolean] don't bother trying to use 'open-uri' (but still tries to open an uri with 'rest-client'). Defaults to +false+ for open-closed principle respect, but advised to be set to +true+
+  # +payload+:: [String] 
+  # +verify_ssl+:: [Boolean] defaults to +false+
+  # +headers+:: [Hash] +"Authorization"+ key will be added to it if +auth_user+ is given. Defaults to +{}+
+  # +method+:: [HTTP method] one of +:get+, +:method+, +:post+ or +:delete+. defaults to +:get+
+  # +timeout+:: [Fixnum, nil] defaults to +nil+
   #
   # @return [String, Object] read data (or +return_on_rescue+)
   def file_read args=ARGV
-    uri, username, password, return_on_rescue, return_on_directory_given = args
-    (require 'open-uri') && open_uri = true
+    uri,
+      username,
+      password,
+      return_on_rescue,
+      return_on_directory_given,
+      skip_open_uri,
+      payload,
+      verify_ssl,
+      headers,
+      method,
+      timeout,
+      reserved = args
+    uri = uri.nne ""
     file_is_directory = File.directory?(uri)
     return_on_directory_given ||= true
-    contents = !(file_is_directory) && open_uri &&  (
+    contents = !(file_is_directory) && (
       begin
-        open(uri, :http_basic_authentication => [username, password]).read
-      rescue  => e
-        return_on_rescue
-      end
-    ) || (!open_uri) && (
-      begin
-        File.read uri
-      rescue  => e
-        return_on_rescue
+        (send :rest_request_or_open_uri_open, [
+            uri,
+            payload,
+            verify_ssl,
+            headers,
+            method,
+            username,
+            password,
+            timeout,
+            skip_open_uri,
+          ]).first
+      rescue => e1
+        begin
+          File.read uri
+        rescue  => e2
+          return_on_rescue
+        end
       end
     ) || (file_is_directory) && (return_on_directory_given)
   end
@@ -808,43 +861,144 @@ class Rubyment
 
 
   # makes a rest request.
-  # for now, the parameters must still be hardcoded.
+  # @param [Array] +args+, an +Array+ whose elements are expected to be:
+  # +url+:: [String] 
+  # +payload+:: [String] 
+  # +verify_ssl+:: [Boolean] 
+  # +headers+:: [Hash] +"Authorization"+ key will be added to it if +auth_user+ is given.
+  # +method+:: [HTTP method] one of +:get+, +:method+, +:post+ or +:delete+
+  # +auth_user+:: [String, nil] username for basic authentication method
+  # +password+:: [String, nil] password for basic authentication method. Will prompt without echo if +nil+ and +auth_user+ is not +nil+
+  # +timeout+:: [Fixnum] 
+  # @return [String] the response
   def rest_request args=ARGV
     require 'base64'
     require 'rest-client'
-    require 'json'
+
     stderr = @memory[:stderr]
     time   = @memory[:time]
+    url,
+      payload,
+      verify_ssl,
+      headers,
+      method,
+      auth_user,
+      password,
+      timeout,
+      reserved = args
+
+    auth_user = auth_user.nne
+    password  = password.nne
+    method    = method.nne :get
+    headers   = headers.nne({})
+    base64_auth = Base64.encode64 [
+      auth_user,
+      auth_user && (input_single_line_non_echo [password])
+    ].join ":"
+    auth_user && (headers["Authorization"] = "Basic #{base64_auth}")
+    request_execution = RestClient::Request.execute(:method => method, :url => url, :payload => payload, :headers => headers, :verify_ssl => verify_ssl, :timeout => timeout)
+    request_execution.to_s
+  end
+
+
+  # calls #rest_request (which depends on +'rest-client'+ gem)
+  # in the case it throws an exception, tries to call
+  # +'open-uri'+'s #open.
+  # note that not the arguments below refer to the #rest_request
+  # for #open, only  +auth_user+ and +password+ will be
+  # forwarded, as they come to this function.
+  # @param [Array] +args+, an +Array+ whose elements are expected to be:
+  # +url+:: [String] 
+  # +payload+:: [String] 
+  # +verify_ssl+:: [Boolean] defaults to +false+
+  # +headers+:: [Hash] +"Authorization"+ key will be added to it if +auth_user+ is given. Defaults to +{}+
+  # +method+:: [HTTP method] one of +:get+, +:method+, +:post+ or +:delete+. defaults to +:get+
+  # +auth_user+:: [String, nil] username for basic authentication method
+  # +password+:: [String, nil] password for basic authentication method. Will prompt without echo if +nil+ and +auth_user+ is not +nil+
+  # +timeout+:: [Fixnum, nil] defaults to +nil+
+  # +skip_open_uri+:: [Boolean] don't bother trying with #open
+  # @return [Array] the response
+  def rest_request_or_open_uri_open args=ARGV
+    url,
+      payload,
+      verify_ssl,
+      headers,
+      method,
+      auth_user,
+      password,
+      timeout,
+      skip_open_uri,
+      reserved = args
+    skip_open_uri = skip_open_uri.nne
+
+    response = runea ["yes, rescue",
+      "output exception".negate_me,
+      "nil on exception"
+    ] {
+      send :rest_request, [
+        url,
+        payload,
+        verify_ssl,
+        headers,
+        method,
+        auth_user,
+        password,
+        timeout,
+      ]
+    }
+    response ||= runea ["yes, rescue".negate_me,
+      "output exception".negate_me,
+      "nil on exception"
+    ] {
+      !skip_open_uri && send(
+        :open,
+        url,
+        :http_basic_authentication => [auth_user, password],
+      ).read
+    }
+    [response]
+  end
+
+
+  # test #rest_request
+  # for now, the parameters must still be hardcoded.
+  def test__rest_request args=ARGV
+    require 'json'
+    stderr = @memory[:stderr]
 
     atlasian_account="my_atlasian_account"
     jira_host = "https://mydomain.atlassian.net/"
     issue = "JIRAISSUE-6517"
     url = "#{jira_host}/rest/api/2/issue/#{issue}/comment"
-    # ways to set base64_auth:
-    # 1) programmatically: let pw in plain text:
-    # auth = "my_user:my_pw"
-    # base64_auth = Base64.encode64 auth
-    # 2) a bit safer (this hash can be still used
-    # to hijack your account):
-    #  echo "my_user:my_pw" | base64 # let a whitespace in the beginning
-    base64_auth = "bXlfdXNlcjpteV9wdwo="
-    # todo: it has to be interactive, or fetch from a keying
-    # to achieve good security standards
-    method = :get
-    method = :post
-    timeout = 2000
-    headers = {"Authorization" => "Basic #{base64_auth}" }
-    verify_ssl = true
+
     json =<<-ENDHEREDOC
     {
         "body" : "my comment"
     }
     ENDHEREDOC
     payload = "#{json}"
-    request_execution = RestClient::Request.execute(:method => method, :url => url, :payload => payload, :headers => headers, :verify_ssl => verify_ssl, :timeout => timeout)
+
+    auth_user = nil
+    password = nil
+    method = :get
+    method = :post
+    timeout = 2000
+    verify_ssl = false
+    payload = "#{json}"
+    headers = ""
+    request_execution = send :rest_request, [
+      url,
+      payload,
+      verify_ssl,
+      headers,
+      method,
+      auth_user,
+      password,
+      timeout,
+    ]
     parsed_json = JSON.parse request_execution.to_s
     stderr.puts parsed_json
-    parsed_json
+    [parsed_json]
   end
 
 
@@ -2540,10 +2694,10 @@ require '#{gem_name}'
       extra_cert_pem_files,
       output_exception,
       reserved = args
-    debug ||= debug.nne
-    extra_cert_pem_files ||= extra_cert_pem_files.nne []
-    admit_plain ||= admit_plain.nne
-    output_exception ||= (
+    debug = debug.nne
+    extra_cert_pem_files = extra_cert_pem_files.nne []
+    admit_plain = admit_plain.nne
+    output_exception = (
       output_exception.nne || admit_plain.negate_me
     )
     debug && (stderr.puts "#{__method__} starting")
@@ -2562,7 +2716,7 @@ require '#{gem_name}'
     
     require 'socket'
     plain_server = TCPServer.new ip_addr, listening_port
-    ssl_server = runea [admit_plain, output_exception] {
+    ssl_server = runea [admit_plain, output_exception, "nil on exception"] {
       require 'openssl'
       ssl_context = OpenSSL::SSL::SSLContext.new
       ssl_context.extra_chain_cert =
@@ -2578,8 +2732,10 @@ require '#{gem_name}'
       ssl_server
     }
 
+    rv = ssl_server || admit_plain && plain_server
+    debug && (stderr.puts "will return #{rv}")
     debug && (stderr.puts "#{__method__} returning")
-    ssl_server || admit_plain && plain_server
+    rv
   end
 
 
@@ -2622,7 +2778,13 @@ require '#{gem_name}'
     debug.nne && (stderr.puts server)
     Thread.start {
       loop {
-        Thread.start(server.accept) { |client|
+        client = runea ["yes, rescue",
+	  "yes, output exception",
+	  "nil on exception"
+	] {
+	  server.accept
+	}
+        Thread.start(client) { |client|
           debug.nne && (stderr.puts Thread.current)
           debug.nne && (stderr.puts client)
           runoe {
@@ -2697,10 +2859,10 @@ require '#{gem_name}'
      http_server_port,
      http_ip_addr,
      reserved = args
-   http_processing_method ||= http_processing_method.nne :http_OK_response
-   http_processing_method_args ||= http_processing_method_args.nne []
-   http_server_port ||= http_server_port.nne  8003
-   http_ip_addr ||= http_ip_addr.nne "0"
+   http_processing_method = http_processing_method.nne :http_OK_response
+   http_processing_method_args = http_processing_method_args.nne []
+   http_server_port = http_server_port.nne  8003
+   http_ip_addr = http_ip_addr.nne "0"
    thread = tcp_server_plain [
      http_server_port,
      http_ip_addr,
@@ -2728,10 +2890,10 @@ require '#{gem_name}'
      http_server_port,
      http_ip_addr,
      reserved = args
-   http_processing_method ||= http_processing_method.nne :http_OK_response
-   http_processing_method_args ||= http_processing_method_args.nne []
-   http_server_port ||= http_server_port.nne  8003
-   http_ip_addr ||= http_ip_addr.nne "0"
+   http_processing_method = http_processing_method.nne :http_OK_response
+   http_processing_method_args = http_processing_method_args.nne []
+   http_server_port = http_server_port.nne  8003
+   http_ip_addr = http_ip_addr.nne "0"
    thread =  tcp_ssl_server [
      http_server_port,
      http_ip_addr,
@@ -2893,16 +3055,16 @@ n8mFEtUKobsK
      extra_cert_pem_files,
      ssl_cert_pkey_chain_method,
      reserved = args
-   http_processing_method ||= http_processing_method.nne :http_OK_response
-   http_processing_method_args ||= http_processing_method_args.nne []
-   http_server_port ||= http_server_port.nne  8003
-   http_ip_addr ||= http_ip_addr.nne "0"
-   ssl_cert_pkey_chain_method ||=
+   http_processing_method = http_processing_method.nne :http_OK_response
+   http_processing_method_args = http_processing_method_args.nne []
+   http_server_port = http_server_port.nne  8003
+   http_ip_addr = http_ip_addr.nne "0"
+   ssl_cert_pkey_chain_method =
      ssl_cert_pkey_chain_method.nne :ssl_sample_self_signed_cert_encrypted
    ssl_cert_pkey_chain = send ssl_cert_pkey_chain_method
-   priv_pemfile  ||=   priv_pemfile.nne ssl_cert_pkey_chain[1]
-   cert_pem_file ||=  cert_pem_file.nne ssl_cert_pkey_chain[0]
-   extra_cert_pem_files ||=  extra_cert_pem_files.nne ssl_cert_pkey_chain[2]
+   priv_pemfile  =   priv_pemfile.nne ssl_cert_pkey_chain[1]
+   cert_pem_file =  cert_pem_file.nne ssl_cert_pkey_chain[0]
+   extra_cert_pem_files =  extra_cert_pem_files.nne ssl_cert_pkey_chain[2]
    thread =  tcp_ssl_server [
      http_server_port,
      http_ip_addr,
@@ -2940,8 +3102,8 @@ n8mFEtUKobsK
   # the file.
   def test__file_read__return_on_rescue args=ARGV
     priv_pemfile, cert_pem_file = args
-    priv_pemfile  ||=  priv_pemfile.nne "/tmp/pkey.pem"
-    cert_pem_file ||= cert_pem_file.nne "/tmp/cert.crt"
+    priv_pemfile  =  priv_pemfile.nne "/tmp/pkey.pem"
+    cert_pem_file = cert_pem_file.nne "/tmp/cert.crt"
     runef { 
      File.delete priv_pemfile
      File.delete cert_pem_file
@@ -3008,6 +3170,173 @@ n8mFEtUKobsK
   end
 
 
+  # test for tcp_ssl_server (calling an +io_method+,
+  # by default #io_transform, with
+  # a function that processes an http request and returns
+  # an http_response, by default #http_OK_response)
+  # just like #test__tcp_ssl_server__non_ssl,
+  # calling directly #tcp_ssl_server, but making
+  # mandatory the server to be ssl one.
+  # requires, by default that the certificate and its
+  #  private key are found in the current dir, which
+  #  can be achieved with:
+  #  +openssl req -x509 -nodes -days 365 -newkey rsa:1024 -keyout pkey.pem -out cert.crt+
+  # but if the files don't exist, they will be created
+  # with a sample self signed certificate.
+  def test__tcp_ssl_server__io_method args = ARGV
+    http_processing_method,
+      http_processing_method_args,
+      http_server_port,
+      http_ip_addr,
+      priv_pemfile,
+      cert_pem_file,
+      extra_cert_pem_files,
+      ssl_cert_pkey_chain_method,
+      debug,
+      happy_with_request,
+      io_method,
+      io_method_debug,
+      admit_non_ssl,
+      reserved = args
+    http_processing_method = http_processing_method.nne :http_OK_response
+    http_processing_method_args = http_processing_method_args.nne []
+    http_server_port = http_server_port.nne  8003
+    http_ip_addr = http_ip_addr.nne "0"
+    ssl_cert_pkey_chain_method =
+      ssl_cert_pkey_chain_method.nne :ssl_sample_self_signed_cert_encrypted
+    ssl_cert_pkey_chain = send ssl_cert_pkey_chain_method
+    priv_pemfile  =   priv_pemfile.nne ssl_cert_pkey_chain[1]
+    cert_pem_file =  cert_pem_file.nne ssl_cert_pkey_chain[0]
+    extra_cert_pemiles =  extra_cert_pem_files.nne ssl_cert_pkey_chain[2]
+    debug =  debug.nne "yes, debug"
+    io_method =  io_method.nne "io_transform"
+    io_method_debug =  io_method_debug.nne debug
+    happy_with_request = happy_with_request.nne
+    admit_non_ssl = admit_non_ssl.nne
+    tcp_ssl_server_args = [
+      http_server_port,
+      http_ip_addr,
+      debug,
+      admit_non_ssl,
+      io_method,
+      [
+        io_method_debug,
+        happy_with_request,
+        http_processing_method,
+        http_processing_method_args
+      ],
+      priv_pemfile,
+      cert_pem_file,
+      extra_cert_pem_files,
+      "yes, output exceptions",
+    ]
+    thread =  tcp_ssl_server tcp_ssl_server_args
+    [ thread ] + tcp_ssl_server_args
+  end
+
+
+  # tests file_read against a uri.
+  # created to test a client for servers
+  # created with
+  # #test__tcp_ssl_server__io_method
+  def test__file_read__uri_root args = ARGV
+    stderr = @memory[:stderr]
+    domain,
+      http_server_port,
+      admit_non_ssl,
+      debug,
+      reserved = args
+    domain = domain.nne "localhost"
+    http_server_port = http_server_port.nne 8003
+    admit_non_ssl = admit_non_ssl.nne true
+    debug = debug.nne
+    stderr.puts admit_non_ssl.inspect
+    stderr.puts (admit_non_ssl && (file_read ["http://#{domain}:#{http_server_port}/"])).inspect
+    response = (file_read ["https://#{domain}:#{http_server_port}/"]) ||
+      admit_non_ssl && (file_read ["http://#{domain}:#{http_server_port}/"])
+    debug && (stderr.puts  "response{#{response}}response")
+    response
+  end
+
+
+  # tests test__tcp_ssl_server__io_method and opens
+  # another thread for the client
+  def test__tcp_ssl_server__get_root args = ARGV
+    stderr = @memory[:stderr]
+    tcp_ssl_server_method,
+      http_processing_method,
+      http_processing_method_args,
+      http_server_port,
+      http_ip_addr,
+      priv_pemfile,
+      cert_pem_file,
+      extra_cert_pem_files,
+      ssl_cert_pkey_chain_method,
+      debug_tcp_ssl_server_method,
+      happy_with_request,
+      io_method,
+      io_method_debug,
+      domain,
+      admit_non_ssl,
+      no_debug_client,
+      reserved = args
+    tcp_ssl_server_method = tcp_ssl_server_method.nne :test__tcp_ssl_server__io_method
+    domain = domain.nne "localhost"
+    http_server_port = http_server_port.nne 8003
+    no_debug_client = no_debug_client.nne
+    server_thread = send tcp_ssl_server_method,
+      [
+        http_processing_method,
+        http_processing_method_args,
+        http_server_port,
+        http_ip_addr,
+        priv_pemfile,
+        cert_pem_file,
+        extra_cert_pem_files,
+        ssl_cert_pkey_chain_method,
+        debug_tcp_ssl_server_method,
+        happy_with_request,
+        io_method,
+        io_method_debug,
+        admit_non_ssl,
+      ]
+
+    thread_2 = Thread.new {
+      loop {
+        response = test__file_read__uri_root [
+          domain,
+          http_server_port,
+          admit_non_ssl,
+          no_debug_client.negate_me,
+        ]
+        sleep 2
+      }
+    }
+    server_thread.first.join
+
+    true
+  end
+
+
+  # experimental stuff coming. usage example:
+  # ./rubyment.rb  invoke_double p test__shell_send_array__main  "tinga" "" sub in EN 
+  # ["tENga"]
+  def test__shell_send_array__main args=[]
+    p args
+    object_to_send,
+      reserved,
+      method_to_send,
+      *args_to_send = args
+    object_to_send = object_to_send.nne
+    method_to_send = method_to_send.nne :main
+    object_to_send && (
+      object_to_send.send method_to_send, *args_to_send
+    ) || (!object_to_send) && (
+      send method_to_send, args_to_send
+    )
+  end
+
+
   # test for Object::nne
   def test__object_nne args = ARGV
     string_neutral = ""
@@ -3086,6 +3415,51 @@ n8mFEtUKobsK
   end
 
 
+  # test #rest_request
+  # for now, the parameters must still be hardcoded.
+  def test__rest_request__with_ayt args=ARGV
+    require 'json'
+    stderr = @memory[:stderr]
+
+    url = "https://owl.loftweb.nl:55031/4/3-roOomydev"
+    json =<<-ENDHEREDOC
+    {
+        "operation" : "AYT",
+        "version" : {
+            "client" : "X",
+            "protocol" : {
+                "domain_model" : "4",
+                "API" : "3"
+            }
+        }
+    }
+    ENDHEREDOC
+    payload = "#{json}"
+
+    auth_user = "web"
+    password = "vadim"
+    method = :post
+    method = :get
+    timeout = 600
+    verify_ssl = true
+    payload = "#{json}"
+    headers = ""
+    request_execution = send :rest_request, [
+      url,
+      payload,
+      verify_ssl,
+      headers,
+      method,
+      auth_user,
+      password,
+      timeout,
+    ]
+    parsed_json = JSON.parse request_execution.to_s
+    stderr.puts parsed_json
+    [parsed_json]
+  end
+
+
 end
 
 (__FILE__ == $0) && Rubyment.new({:invoke => ARGV})

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubyment
 version: !ruby/object:Gem::Version
-  version: 0.6.25510166
+  version: 0.6.25520442
 platform: ruby
 authors:
 - Ribamar Santarosa