matterhorn_whymper 0.4.0 → 0.5.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    Yzk1NWZlZTUzZDA1ZTQxOGVlZTk3Mjg1YmJkOTNhZDA2OGU2MTdlNA==
+    YjliZDhiZTllYjViZDZlMDRlNDBkMDk2Y2NjZDJlYjE2ODU3OTlmNA==
   data.tar.gz: !binary |-
-    YTJhMzA5Yzk2N2M1M2NkYjI2NDlhNTRmZTA1ODdiNTE5MDcyYWRhZQ==
+    ODkzN2MzZjJmYzc3YjJhMTc0M2UzZTg0ZWVmYTRmZGY5ZDJmNTYwMg==
 SHA512:
   metadata.gz: !binary |-
-    MGNmOWU0YzIxZDhlNjI4YjFhZGE5ZTFkY2Y3ZjYzOGZkMmY1OGQxNTMyMmMw
-    ZDYxNWZiZjU3YjFlYWNjYTc1M2UzYzc0MDc2Y2M4ZTM0YmMyZmE5ZGEyMjgy
-    YjdjNjgzZjc3NjVmY2RjNDZmYWUzMDMzNzQ0MzFjYmEwMTQxNzE=
+    ZDM4YzBhODU2MmU3YTdhNzFjM2Y2NDdjYzYyNjg4ZjAwZmZlNTllYTYwMTM3
+    YzNjM2FkOTdjNjFhZWNiOWRhOTdkZDJmYWUwNDNjZjc2ZDhmOTM5MzU2MDlm
+    MTA0ZTdhMDRmODBjMDYxNmU1MWQxYzVlZjQxYWYwMmQwNDhmNWY=
   data.tar.gz: !binary |-
-    MjMwOWNmNjNjZWI2YjY2NDU3ZGNmY2QzNTg3ZmUyMWE1ODIxMDM0YzBmN2E0
-    YzI4MTJlY2IwZTUwNTE2MmJkNjhjNDViNWU3MWMyMGJlOGY2NmZkOWFhY2Fi
-    NjIwMTdjNjk2YzU3ZGE1NGQ4ZDAzMzRhYTljNzBmODVmODVmNDY=
+    OGY2ZjhjYmQ4MDljZGQyYTEzMTAwMTdjY2Y4OWFiY2ZjOTBkMGIzYTg0OGJk
+    Mzg5MDg5NzI0NTA1MWUzNmRlNzBlZmMwYjQ0YThhZjUxNTJkNWJkMDM4NTMx
+    NWEzMDM4YWRhZmE3OTI5ZjZkMWNiYzdkMzliODEzNzdlZjA0ZTc=

data/lib/matterhorn/acl.rb

@@ -0,0 +1,93 @@
+require 'nokogiri'
+
+
+# ============================================================================== Matterhorn::Acl ===
+
+# <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+# <acl xmlns="http://org.opencastproject.security">
+#   <ace>
+#     <role>admin</role>
+#     <action>delete</action>
+#     <allow>true</allow>
+#   </ace>
+# </acl>
+#
+#
+class Matterhorn::Acl
+
+  attr_accessor :aces
+
+
+  # ======================================================================= Matterhorn::Acl::Ace ===
+
+  class Ace
+
+    attr_accessor :role, :action, :allow
+
+    def initialize(role = nil, action = nil, allow = true)
+      @role = role
+      @action = action
+      @allow = allow
+    end
+
+  end # --------------------------------------------------------------- end Matterhorn::Acl::Ace ---
+ 
+
+  # -------------------------------------------------------------------------- const definitions ---
+
+  NS = {
+    'xmlns' => "http://org.opencastproject.security",
+  }
+
+
+  # ----------------------------------------------------------------------------- initialization ---
+
+  def initialize(xml = nil)
+    if !xml.nil?
+      doc = Nokogiri::XML(xml)
+      @aces = []
+      doc.xpath("/xmlns:acl/xmlns:ace").each do |ace_elem|
+        ace = Ace.new
+        ace.role   = ace_elem.at_xpath("xmlns:role").content
+        ace.action = ace_elem.at_xpath("xmlns:action").content
+        ace.allow  = ace_elem.at_xpath("xmlns:allow").content
+        @aces << ace
+      end
+    else
+      @aces = []
+    end
+  end
+
+
+  # ----------------------------------------------------------------------------------- methodes ---
+
+  def save(file)
+    File.open(file, 'w') do |file|
+      file.write(to_xml)
+    end
+  end
+
+
+  def to_xml
+    Nokogiri::XML::Builder.new do |xml|
+      xml.acl(NS) do
+        @aces.each do |ace|
+          xml.ace do 
+            xml.role(ace.role)
+            xml.action(ace.action)
+            xml.allow(ace.allow)
+          end
+        end
+      end
+    end.doc.to_xml
+  end
+
+
+  # ------------------------------------------------------------------------------------ helpers ---
+
+  def inspect
+    to_xml.to_s
+  end
+
+
+end # ---------------------------------------------------------------------- end Matterhorn::Acl ---

data/lib/matterhorn/dublin_core.rb

@@ -0,0 +1,171 @@
+require 'nokogiri'
+
+
+# ======================================================================= Matterhorn::DublinCore ===
+
+
+# <?xml version="1.0"?>
+# <dublincore xmlns="http://www.opencastproject.org/xsd/1.0/dublincore/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+#   xsi:schemaLocation="http://www.opencastproject.org http://www.opencastproject.org/schema.xsd" xmlns:dc="http://purl.org/dc/elements/1.1/"
+#   xmlns:dcterms="http://purl.org/dc/terms/" xmlns:oc="http://www.opencastproject.org/matterhorn/">
+#   <dcterms:title xml:lang="en">
+#     Land and Vegetation: Key players on the Climate Scene
+#     </dcterms:title>
+#   <dcterms:subject>
+#     climate, land, vegetation
+#     </dcterms:subject>
+#   <dcterms:description xml:lang="en">
+#     Introduction lecture from the Institute for
+#     Atmospheric and Climate Science.
+#     </dcterms:description>
+#   <dcterms:publisher>
+#     ETH Zurich, Switzerland
+#     </dcterms:publisher>
+#   <dcterms:identifier>
+#     10.0000/5819
+#     </dcterms:identifier>
+#   <dcterms:modified xsi:type="dcterms:W3CDTF">
+#     2007-12-05
+#     </dcterms:modified>
+#   <dcterms:format xsi:type="dcterms:IMT">
+#     video/x-dv
+#     </dcterms:format>
+#   <oc:promoted>
+#     true
+#   </oc:promoted>
+# </dublincore>
+#
+#
+class Matterhorn::DublinCore
+ 
+  # -------------------------------------------------------------------------- const definitions ---
+
+  NS = {
+    'xmlns'              => "http://www.opencastproject.org/xsd/1.0/dublincore/",
+    'xmlns:xsi'          => "http://www.w3.org/2001/XMLSchema-instance",
+    'xsi:schemaLocation' => "http://www.opencastproject.org http://www.opencastproject.org/schema.xsd",
+    'xmlns:dc'           => "http://purl.org/dc/elements/1.1/",
+    'xmlns:dcterms'      => "http://purl.org/dc/terms/",
+    'xmlns:oc'           => "http://www.opencastproject.org/matterhorn/"
+  }
+
+
+  # ----------------------------------------------------------------------------- initialization ---
+
+  def initialize(xml = nil)
+    if !xml.nil?
+      @document = Nokogiri::XML(xml)
+    else
+      @document = Nokogiri::XML::Builder.new do |xml|
+        xml.dublincore(NS) do
+        end
+      end
+      .doc
+    end
+  end
+
+
+  # ----------------------------------------------------------------------------------- methodes ---
+
+  def document
+    @document
+  end
+
+  
+  def save(file)
+    File.open(file, 'w') do |file|
+      file.write(@document.to_xml)
+    end
+  end
+
+
+  def to_xml
+    @document.to_xml
+  end
+
+
+  def inspect
+    to_xml.to_s
+  end
+
+
+  def method_missing(method, *args, &block)
+    # analyse mehtod
+    splitted_method = method.to_s.split('_')
+    if splitted_method.first == 'add'
+      method_name = :add_value
+      splitted_method.shift
+    elsif splitted_method.first == 'list'
+      method_name = :list_value
+      splitted_method.shift
+    elsif splitted_method.last.end_with?('=')
+      method_name = :set_value
+      splitted_method.last.chop!
+    else
+      method_name = :get_value
+    end
+
+    # namespace, key and value
+    namespace = if !get_ns(splitted_method.first).nil?
+                  splitted_method.shift
+                else
+                  'xmlns'
+                end
+    key       = splitted_method.join('_')
+    value     = args[0]
+    MatterhornWhymper.logger.debug { "#{self.class.name}#method_missing | " +
+                                     "method: #{method_name.to_s}; namespace: #{namespace}; " +
+                                     "key: #{key}; value: #{value.to_s}" }
+
+    # call method
+    params = case method_name
+             when :get_value then [namespace, key]
+             when :set_value then [namespace, key, args[0].to_s]
+             when :add_value then [namespace, key, args[0].to_s]
+             end
+    send(method_name, *params)
+  end  
+
+
+  # ------------------------------------------------------------------------------------ helpers ---
+
+  def get_ns(ns)
+    @document.root.namespace_definitions.find { |n| n.prefix == ns }
+  end
+
+
+  def get_value(ns, key)
+    elem = @document.xpath("/xmlns:dublincore/#{ns}:#{key}").first
+    return nil    if elem.nil?
+    elem.content
+  end
+
+
+  def set_value(ns, key, value)
+    if !(elem = @document.at_xpath("/xmlns:dublincore/#{ns}:#{key}")).nil?
+      elem.content = value
+    else
+      elem = Nokogiri::XML::Element.new(key, @document)
+      elem.content = value
+      elem.namespace = get_ns(ns)    unless ns.nil?
+      @document.root << elem
+    end
+    elem.content
+  end
+
+
+  def add_value(ns, key, value)
+    sibling = @document.xpath("/xmlns:dublincore/#{ns}:#{key}").last
+    elem = Nokogiri::XML::Element.new(key, @document)
+    elem.content = value
+    elem.namespace = get_ns(ns)    unless ns.nil?
+    if !sibling.nil?
+      sibling.after(elem)
+    else
+      @document.root << elem
+    end
+    elem.content
+  end
+
+  
+end # --------------------------------------------------------------- end Matterhorn::DublinCore ---

data/lib/matterhorn/endpoint/ingest.rb

@@ -9,20 +9,19 @@ class Matterhorn::Endpoint::Ingest < Matterhorn::Endpoint
     unless @media_pkg_remote then raise(Matterhorn::Error, "No media package is available!"); end
     @media_pkg_local.add_attachment(file, flavor)    if @media_pkg_local
     begin
-      @media_pkg_remote = http_client.post(
+      spit_response http_client.post(
         "ingest/addAttachment",
         { 'flavor' => flavor,
           'mediaPackage' => @media_pkg_remote,
           'BODY' => file
         }
-      ).body
-    rescue Matterhorn::HttpClientError => ex
-      MatterhornWhymper.logger.error { "#{self.class.name}::addAttachment | " +
-                                 "Media package not valid! / media package:\n#{@media_pkg_remote}" }
-      raise ex
-    rescue Matterhorn::HttpServerError => ex
-      MatterhornWhymper.logger.error { "#{self.class.name}::addAttachment | " +
-                                       "Internal server error on Matterhorn!" }
+      )
+      @media_pkg_remote = response_body
+    rescue => ex
+      exception_handler('addAttachment', ex, {
+          400 => "Media package not valid! / media package:\n#{@media_pkg_remote}"
+        }
+      )
       raise ex
     end
     @media_pkg_remote
@@ -33,20 +32,19 @@ class Matterhorn::Endpoint::Ingest < Matterhorn::Endpoint
     unless @media_pkg_remote then raise(Matterhorn::Error, "No media package is available!"); end
     @media_pkg_local.add_catalog(file, flavor)    if @media_pkg_local
     begin
-      @media_pkg_remote = http_client.post(
+      split_response http_client.post(
         "ingest/addCatalog",
         { 'flavor' => flavor,
           'mediaPackage' => @media_pkg_remote,
           'BODY' => file
         }
-      ).body
-    rescue Matterhorn::HttpClientError => ex
-      MatterhornWhymper.logger.error { "#{self.class.name}::addCatalog | " +
-                                 "Media package not valid! / media package:\n#{@media_pkg_remote}" }
-      raise ex
-    rescue Matterhorn::HttpServerError => ex
-      MatterhornWhymper.logger.error { "#{self.class.name}::addCatalog | " +
-                                       "Internal server error on Matterhorn!" }
+      )
+      @media_pkg_remote = response_body
+    rescue => ex
+      exception_handler('addCatalog', ex, {
+          400 => "Media package not valid! / media package:\n#{@media_pkg_remote}"
+        }
+      )
       raise ex
     end
     @media_pkg_remote
@@ -57,20 +55,19 @@ class Matterhorn::Endpoint::Ingest < Matterhorn::Endpoint
     unless @media_pkg_remote then raise(Matterhorn::Error, "No media package is available!"); end
     @media_pkg_local.add_dc_catalog(dublin_core)    if @media_pkg_local
     begin
-      @media_pkg_remote = http_client.post(
+      split_response http_client.post(
         "ingest/addDCCatalog",
         { 'flavor' => 'dublincore/episode',
           'mediaPackage' => @media_pkg_remote,
           'dublinCore' => dublin_core
         }
-      ).body
-    rescue Matterhorn::HttpClientError => ex
-      MatterhornWhymper.logger.error { "#{self.class.name}::addDCCatalog | " +
-                                 "Media package not valid! / media package:\n#{@media_pkg_remote}" }
-      raise ex
-    rescue Matterhorn::HttpServerError => ex
-      MatterhornWhymper.logger.error { "#{self.class.name}::addDCCatalog | " +
-                                       "Internal server error on Matterhorn!" }
+      )
+      @media_pkg_remote = response_body
+    rescue => ex
+      exception_handler('create', ex, {
+          400 => "Media package not valid! / media package:\n#{@media_pkg_remote}"
+        }
+      )
       raise ex
     end
     @media_pkg_remote
@@ -82,33 +79,29 @@ class Matterhorn::Endpoint::Ingest < Matterhorn::Endpoint
     unless @media_pkg_remote then raise(Matterhorn::Error, "No media package is available!"); end
     @media_pkg_local.add_track(file_or_url, flavor) if @media_pkg_local
     begin
-      @media_pkg_remote = 
-        if HTTP_PROTOCOL_RE =~ file_or_url
-          http_client.post(
-            "ingest/addTrack",
-            {
-              'flavor' => flavor,
-              'mediaPackage' => @media_pkg_remote,
-              'url' => file_or_url
-            }
-          ).body
-        else
-          http_client.post(
-            "ingest/addTrack",
-            {
-              'flavor' => flavor,
-              'mediaPackage' => @media_pkg_remote,
-              'BODY' => file_or_url
-            }
-          ).body
-        end
-    rescue Matterhorn::HttpClientError => ex
-      MatterhornWhymper.logger.error { "#{self.class.name}::addTrack | " +
-                                 "Media package not valid! / media package:\n#{@media_pkg_remote}" }
-      raise ex
-    rescue Matterhorn::HttpServerError => ex
-      MatterhornWhymper.logger.error { "#{self.class.name}::addTrack | " +
-                                       "Internal server error on Matterhorn!" }
+      if HTTP_PROTOCOL_RE =~ file_or_url
+        split_response http_client.post(
+          "ingest/addTrack",
+          { 'flavor' => flavor,
+            'mediaPackage' => @media_pkg_remote,
+            'url' => file_or_url
+          }
+        )
+      else
+        split_response http_client.post(
+          "ingest/addTrack",
+          { 'flavor' => flavor,
+            'mediaPackage' => @media_pkg_remote,
+            'BODY' => file_or_url
+          }
+        )
+      end
+      @media_pkg_remote = response_body
+    rescue => ex
+      exception_handler('addTrack', ex, {
+          400 => "Media package not valid! / media package:\n#{@media_pkg_remote}"
+        }
+      )
       raise ex
     end
     @media_pkg_remote
@@ -123,12 +116,12 @@ class Matterhorn::Endpoint::Ingest < Matterhorn::Endpoint
     if @media_pkg_remote then raise(Matterhorn::Error, "A media package is allready created!"); end
     @media_pkg_local = source_path ? Matterhorn::MediaPackage.new(source_path) : nil
     begin
-      @media_pkg_remote = http_client.get(
+      split_response http_client.get(
         "ingest/createMediaPackage"
-      ).body
-    rescue Matterhorn::HttpServerError => ex
-      MatterhornWhymper.logger.error { "#{self.class.name}::createMediaPackage | " +
-                                       "Internal server error on Matterhorn!" }
+      )
+      @media_pkg_remote = response_body
+    rescue => ex
+      exception_handler('createMediaPackage', ex, {})
       raise ex
     end
     @media_pkg_remote
@@ -140,17 +133,16 @@ class Matterhorn::Endpoint::Ingest < Matterhorn::Endpoint
     @media_pkg_local.save    if @media_pkg_local
     options['mediaPackage'] = @media_pkg_remote
     begin
-      @workflow_inst = http_client.post(
+      split_response http_client.post(
         "ingest/ingest/#{wdID}",
         options
-      ).body
-    rescue Matterhorn::HttpClientError => ex
-      MatterhornWhymper.logger.error { "#{self.class.name}::ingest | " +
-                                 "Media package not valid! / media package:\n#{@media_pkg_remote}" }
-      raise ex
-    rescue Matterhorn::HttpServerError => ex
-      MatterhornWhymper.logger.error { "#{self.class.name}::ingest | " +
-                                       "Internal server error on Matterhorn!" }
+      )
+      @workflow_inst = response_body
+    rescue => ex
+      exception_handler('create', ex, {
+          400 => "Media package not valid! / media package:\n#{@media_pkg_remote}"
+        }
+      )
       raise ex
     end
     workflow_instance

data/lib/matterhorn/endpoint/series.rb

@@ -0,0 +1,177 @@
+require 'uri'
+
+
+# ================================================================= Matterhorn::Endpoint::Series ===
+
+class Matterhorn::Endpoint::Series < Matterhorn::Endpoint
+
+
+  # -------------------------------------------------------------------------- endpoint methodes ---
+
+  # ------------------------------------------------------------------------------------- create ---
+
+  # Create a new Series on Mattherhorn.
+  # Return the dublin core of the created Series.
+  # In the property dcterms:identifier is written the Matterhorn Series Id.
+  #
+  def create(dublin_core, acl = nil)
+    dc = nil
+    begin
+      split_response http_client.post(
+        "series",
+        { 'series' => dublin_core.to_xml, 'acl' => acl ? acl.to_xml : '' }
+      )
+      dc = Matterhorn::DublinCore.new(response_body)
+    rescue => ex
+      exception_handler('create', ex, {
+          400 => "The required form params were missing to create the series!\n" +
+                 "    dubline_core:\n#{dublin_core.inspect}\n    acl:\n#{acl.inspect}",
+          401 => "Unauthorized. It is required to authenticate first, before create a series!"
+        }
+      )
+    end
+    dc
+  end
+
+
+  # --------------------------------------------------------------------------------------- read ---
+
+  def read(series_id)
+    dc_model = nil
+    begin
+      split_response http_client.get(
+        "series/#{series_id}.xml"
+      )
+      dc_model = Matterhorn::DublinCore.new(response_body)
+    rescue => ex
+      exception_handler('read', ex, {
+          401 => "Unauthorized. It is required to authenticate first, " +
+                 "before get the content of series #{series_id}.",
+          403 => "It is forbidden to get the content of series #{series_id}.",
+          404 => "The content of series #{series_id} could not be get."
+        }
+      )
+    end
+    dc_model
+  end
+
+  
+  def read_acl(series_id)
+    acl_model = nil
+    begin
+      split_response http_client.get(
+        "series/#{series_id}/acl.xml"
+      )
+      acl_model = Matterhorn::Acl.new(response_body)
+    rescue => ex
+      exception_handler('acl', ex, {
+          404 => "The acl of series #{series_id} could not be found."
+        }
+      )
+    end
+    acl_model
+  end
+
+  
+  def find(options)
+    dc_models = []
+    begin
+      split_response http_client.get(
+        "series/series.xml#{build_query_str(options)}"
+      )
+      Nokogiri::XML(response_body).
+      xpath("/dublincorelist/xmlns:dublincore", Matterhorn::DublinCore::NS).each do |dc_elem|
+        dc_models << Matterhorn::DublinCore.new(dc_elem.to_xml)
+      end
+    rescue => ex
+      exception_handler('filter', ex, {
+          401 => "Unauthorized. It is required to authenticate first, " +
+                 "before filter series."
+        }
+      )
+    end
+    dc_models
+  end
+
+
+  def count
+    count = 0
+    begin
+      split_response http_client.get(
+        "series/count"
+      )
+      count = response_body.to_i
+    rescue => ex
+      exception_handler('count', ex, {})
+    end
+    count
+  end
+
+  
+  # ------------------------------------------------------------------------------------- update ---
+
+  # Updates a given Series on Mattherhorn.
+  # In the property dcterms:identifier must be written the Matterhorn Series Id of the Series
+  # which should be updated.
+  # Return the dublin core of the updated Series.
+  #
+  def update(dublin_core, acl = nil)
+    series_id = dublin_core.dcterms_identifier
+    dc_to_update = read(dublin_core.dcterms_identifier)
+    if dc_to_update.nil?
+      raise(Matterhorn::Matterhorn::Error.new("Series[#{series_id}] was not found on Matterhorn"))
+    end
+    dc = create(dublin_core, acl)
+    if response_code == 204
+      dc = read(series_id)
+    end
+    dc
+  end
+
+
+  def update_acl(series_id, acl)
+    acl_updated = false
+    begin
+      split_response http_client.post(
+        "series/#{series_id}/accesscontrol", { 'acl' => acl.to_xml }
+      )
+      acl_updated = true
+    rescue => ex
+      exception_handler('update_acl', ex, {
+          400 => "Bad request. The required param acl was missing. acl: #{acl.inspect}",
+          401 => "Unauthorized. It is required to authenticate first, " +
+                 "before update the acl of series #{series_id}.",
+          404 => "The series #{series_id} could not be found."
+        }
+      )
+    end
+    acl_updated
+  end
+  
+
+  # ------------------------------------------------------------------------------------- delete ---
+
+  def delete(series_id)
+    deleted = false
+    begin
+      split_response http_client.delete(
+        "series/#{series_id}"
+      )
+      deleted = true
+    rescue => ex
+      exception_handler('delete', ex, {
+          401 => "Unauthorized. It is required to authenticate first, " +
+                 "before delete series #{series_id}.",
+          404 => "The series #{series_id} could not be found."
+        }
+      )
+    end
+    deleted
+  end   
+
+
+  # ---------------------------------------------------------------------------- private section ---
+  private
+
+
+end # --------------------------------------------------------- end Matterhorn::Endpoint::Series --

data/lib/matterhorn/endpoint/workflow.rb

@@ -6,87 +6,72 @@ class Matterhorn::Endpoint::Workflow < Matterhorn::Endpoint
   # -------------------------------------------------------------------------- endpoint methodes ---
 
   def instance(wi_id)
+    wi = nil
     begin
-      wi = http_client.get(
+      split_response http_client.get(
         "workflow/instance/#{wi_id}.xml"
-      ).body
-    rescue Matterhorn::HttpClientError, Matterhorn::HttpServerError => ex
-      if ex.code == 404
-        wi = nil
-        MatterhornWhymper.logger.warn { "#{self.class.name}::instance | " +
-                   "WorkflowInstance[#{wi_id}]: No workflow instance with that identifier exists." }
-      else
-        MatterhornWhymper.logger.error { "#{self.class.name}::instance | " +
-                                "WorkflowInstance[#{wi_id}]: Internal server error on Matterhorn!" }
-
-        raise ex
-      end
+      )
+      wi = response_body
+    rescue => ex
+      exception_handler('instance', ex, {
+          404 => "WorkflowInstance[#{wi_id}]: No workflow instance with that identifier exists."
+        }
+      )
     end
     wi ? Matterhorn::WorkflowInstance.new(wi) : nil
   end
 
 
   def remove(wi_id)
+    wi_removed = false
     begin
-      http_client.delete(
+      split_response http_client.delete(
         "workflow/remove/#{wi_id}"
       )
       wi_removed = true
-    rescue Matterhorn::HttpClientError, Matterhorn::HttpServerError  => ex
-      if ex.code == 404
-        wi_removed = false
-        MatterhornWhymper.logger.warn { "#{self.class.name}::remove | " +
-                   "WorkflowInstance[#{wi_id}]: No workflow instance with that identifier exists." }
-      else
-        MatterhornWhymper.logger.error { "#{self.class.name}::remove | " +
-                                "WorkflowInstance[#{wi_id}]: Internal server error on Matterhorn!" }
-
-        raise ex
-      end
+    rescue => ex
+      exception_handler('remove', ex, {
+          404 => "WorkflowInstance[#{wi_id}]: No workflow instance with that identifier exists."
+        }
+      )
     end
     wi_removed
   end
 
 
   def resume(wi_id)
+    wi = nil
     begin
-      wi = http_client.post(
+      split_response http_client.post(
         "workflow/resume",
         { 'id' => wi_id }
-      ).body
-    rescue Matterhorn::HttpClientError, Matterhorn::HttpServerError  => ex
-      if ex.code == 404
-        wi = nil
-        MatterhornWhymper.logger.warn { "#{self.class.name}::resume | " +
-         "WorkflowInstance[#{wi_id}]: No suspended workflow instance with that identifier exists." }
-      else
-        MatterhornWhymper.logger.error { "#{self.class.name}::resume | " +
-                                "WorkflowInstance[#{wi_id}]: Internal server error on Matterhorn!" }
-
-        raise ex
-      end
+      )
+      wi = response_body
+    rescue => ex
+      exception_handler('resume', ex, {
+          404 => "WorkflowInstance[#{wi_id}]: No suspended workflow instance " +
+                 "with that identifier exists."
+        }
+      )
     end
     wi ? Matterhorn::WorkflowInstance.new(wi) : nil
   end
 
 
   def stop(wi_id)
+    wi = nil
     begin
-      wi = http_client.post(
+      split_response http_client.post(
         "workflow/stop",
         { 'id' => wi_id }
-      ).body
-    rescue Matterhorn::HttpClientError, Matterhorn::HttpServerError  => ex
-      if ex.code == 404
-        wi = nil
-        MatterhornWhymper.logger.warn { "#{self.class.name}::stop | " +
-           "WorkflowInstance[#{wi_id}]: No running workflow instance with that identifier exists." }
-      else
-        MatterhornWhymper.logger.error { "#{self.class.name}::stop | " +
-                                "WorkflowInstance[#{wi_id}]: Internal server error on Matterhorn!" }
-
-        raise ex
-      end
+      )
+      wi = response_body
+    rescue => ex
+      exception_handler('stop', ex, {
+          404 => "WorkflowInstance[#{wi_id}]: No running workflow instance " +
+                 "with that identifier exists."
+        }
+      )
     end
     wi ? Matterhorn::WorkflowInstance.new(wi) : nil
   end

data/lib/matterhorn/endpoint.rb

@@ -1,56 +1,129 @@
-# =================================================================================== Matterhorn ===
+# ========================================================================= Matterhorn::Endpoint ===
 
-module Matterhorn
+class Matterhorn::Endpoint
 
+  # --------------------------------------------------------------------------------- attributes ---
 
-  # ======================================================================= Matterhorn::Endpoint ===
+  attr_reader :response_code, :response_body
 
-  class Endpoint
 
-    # ------------------------------------------------------------------------------- attributes ---
-  
-    attr_reader :http_client
+  # ----------------------------------------------------------------------------- initialization ---
+
+  def self.create(endpoint)
+    if endpoint.respond_to? 'to_s'
+      endpoint = endpoint.to_s.capitalize
+    else
+      raise(Matterhorn::Error, "Matterhorn::Endpoint::open | " +
+                               "#{endpoint.inspect} does not respond to 'to_s'")
+    end
+    endpoint = Object.const_get('Matterhorn').const_get('Endpoint').const_get(endpoint).new
+    if endpoint.nil? || !endpoint.kind_of?(Matterhorn::Endpoint)
+      raise(Matterhorn::Error, "Matterhorn::Endpoint::open | " +
+                               "#{endpoint ? endpoint.class.name : 'nil'} is not a sub class " +
+                               "of 'Matterhorn::Endpoint'!")
+    end
+    endpoint
+  end
+
+
+  def self.open(endpoint)
+    endpoint = create(endpoint)
+    begin
+      yield endpoint
+    ensure
+      endpoint.close
+    end
+  end  
+
+
+  def initialize
+    @http_client = Matterhorn::HttpClient.new(
+      MatterhornWhymper.configuration.uri,
+      MatterhornWhymper.configuration.http_timeout,
+      MatterhornWhymper.configuration.ssl_dont_verify_cert
+    )
+    @response_code = 200
+    @response_body = nil
+    @error_msg = ''
+  end
+
+
+  # ----------------------------------------------------------------------------------- methodes ---
+
+  def error_occurred?
+    response_code >= 400
+  end
+
+
+  def error_code
+    error_occurred? ? response_code : nil
+  end
+
+
+  def error_msg
+    error_occurred? ? @error_msg : ''
+  end
+
+
+  def close
+    http_client.close
+  end
+
+
+  # ---------------------------------------------------------------------- *** protected section ***
+  protected
   
+  def http_client
+    @http_client
+  end
+
 
-    # --------------------------------------------------------------------------- initialization ---
+  def split_response(response)
+    @response_code = response.code.to_i
+    @response_body = response.body
+  end
   
-    def self.open(endpoint)
-      if endpoint.respond_to? 'to_s'
-        endpoint = endpoint.to_s.capitalize
+
+  def exception_handler(method, exception, code_error_msg_hash)
+    res_code = 0
+    error_msg = ''
+    case exception
+    when Matterhorn::HttpClientError
+      res_code = exception.code
+      error_msg = if (msg = code_error_msg_hash[res_code]).nil?
+        "An unspezified error (#{res_code}) has occurred!"
       else
-        raise(Matterhorn::Error, "Matterhorn::Endpoint::open | " +
-                                 "#{endpoint.inspect} does not respond to 'to_s'")
-      end
-      endpoint = Object.const_get('Matterhorn').const_get('Endpoint').const_get(endpoint).new
-      if endpoint.nil? || !endpoint.kind_of?(Matterhorn::Endpoint)
-        raise(Matterhorn::Error, "Matterhorn::Endpoint::open | " +
-                                 "#{endpoint ? endpoint.class.name : 'nil'} is not a sub class " +
-                                 "of 'Matterhorn::Endpoint'!")
-      end 
-      begin
-        yield endpoint
-      ensure
-        endpoint.close
+        msg
       end
-    end  
-  
-  
-    def initialize
-      @http_client = Matterhorn::HttpClient.new(
-        MatterhornWhymper.configuration.uri,
-        MatterhornWhymper.configuration.http_timeout
-      )
+      log_warn_with_res_code_and_error_msg(method, res_code, error_msg)
+    when Matterhorn::HttpServerError
+      res_code = exception.code
+      log_error_with_res_code(method, res_code)
+      raise exception
+    else
+      log_fatal_with_backtrace(method, exception)
+      raise exception
     end
-  
-  
-    # --------------------------------------------------------------------------------- methodes ---
+    @response_code = res_code
+    @error_msg     = error_msg
+  end
 
-    def close
-      http_client.close
-    end
+
+  def log_warn_with_res_code_and_error_msg(method, code, error_msg)
+    MatterhornWhymper.logger.warn { "#{self.class.name}##{method} | #{code}: #{error_msg}" }
+  end 
+
+ 
+  def log_error_with_res_code(method, code)
+    MatterhornWhymper.logger.error { "#{self.class.name}##{method} | #{code}: " +
+                                     "An internal server error has occurred on Matterhorn!" }
+  end 
 
 
-  end # --------------------------------------------------------------- end Matterhorn::Endpoint ---
+  def log_fatal_with_backtrace(method, ex)
+    MatterhornWhymper.logger.fatal { Matterhorn::Error.format_message(
+        "#{self.class.name}##{method} | A general error has occurred!", ex) }
+  end 
 
 
-end # --------------------------------------------------------------------------- end Matterhorn ---
+end # ----------------------------------------------------------------- end Matterhorn::Endpoint ---

data/lib/matterhorn/error.rb

@@ -1,33 +1,29 @@
-# =================================================================================== Matterhorn ===
+# ====================================================================== several error classes ===
 
-module Matterhorn
-
-
-  # ====================================================================== several error classes ===
-
-  class Error < StandardError
+class Matterhorn::Error < StandardError
+  def self.format_message(msg, ex)
+    "#{msg}\n" +
+    "#{ex.class.name}: #{ex.to_s}\n    backtrace:\n    #{ex.backtrace.join("\n    ")}"
   end
-  
+end
 
-  class HttpGeneralError < Matterhorn::Error
 
-    attr_reader :request, :response, :code
+class Matterhorn::HttpGeneralError < Matterhorn::Error
 
-    def initialize(request, response)
-      @request  = request
-      @response = response
-      @code     = response.code.to_i
-    end
+  attr_reader :request, :response, :code
 
+  def initialize(request, response)
+    @request  = request
+    @response = response
+    @code     = response.code.to_i
   end
 
+end
 
-  class HttpClientError < Matterhorn::HttpGeneralError
-  end
 
-  
-  class HttpServerError < Matterhorn::HttpGeneralError
-  end
+class Matterhorn::HttpClientError < Matterhorn::HttpGeneralError
+end
 
 
-end # --------------------------------------------------------------------------- end Matterhorn ---
+class Matterhorn::HttpServerError < Matterhorn::HttpGeneralError
+end

data/lib/matterhorn/http_client.rb

@@ -13,17 +13,18 @@ module Matterhorn
     
     # ------------------------------------------------------------------------------- attributes ---
   
-    attr_reader :base_uri, :host, :port, :ssl, :timeout
+    attr_reader :base_uri, :host, :port, :ssl, :ssl_dont_verify_cert, :timeout
   
 
     # --------------------------------------------------------------------------- initialization ---
   
-    def initialize(base_uri, http_timeout = nil)
+    def initialize(base_uri, http_timeout = nil, ssl_dont_verify_cert = false)
       @base_uri  = URI.parse(base_uri)
       @host      = @base_uri.host
       @port      = @base_uri.port
       @ssl       = @port == 443 ? true : false
       @timeout   = http_timeout
+      @ssl_dont_verify_cert = ssl_dont_verify_cert
     end  
   
 
@@ -63,6 +64,7 @@ module Matterhorn
       return @http_socket   if !@http_socket.nil? && @http_socket.started?
       @http_socket = Net::HTTP.new(host, port)
       @http_socket.use_ssl = ssl
+      @http_socket.verify_mode = OpenSSL::SSL::VERIFY_NONE    if ssl && ssl_dont_verify_cert
       if !timeout.nil?
         @http_socket.open_timeout = timeout
         @http_socket.read_timeout = timeout

data/lib/matterhorn_whymper/version.rb

@@ -5,7 +5,7 @@ module MatterhornWhymper
 
   # -------------------------------------------------------------------------- const definitions ---
 
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 
 
 end # -------------------------------------------------------------------- end MatterhornWhymper ---

data/lib/matterhorn_whymper.rb

@@ -1,6 +1,15 @@
+# Define Matterhorn Namespace
+#
+module Matterhorn
+end
+
+
 require 'matterhorn_whymper/version'
+require 'matterhorn/acl'
+require 'matterhorn/dublin_core'
 require 'matterhorn/endpoint'
 require 'matterhorn/endpoint/ingest'
+require 'matterhorn/endpoint/series'
 require 'matterhorn/endpoint/workflow'
 require 'matterhorn/error'
 require 'matterhorn/http_client'
@@ -49,7 +58,7 @@ module MatterhornWhymper
     # ------------------------------------------------------------------------------- attributes --- 
 
     attr_accessor :system_account_user, :system_account_password, :system_domain, :system_protocol,
-                  :http_timeout
+                  :http_timeout, :ssl_dont_verify_cert
 
 
     # --------------------------------------------------------------------------------- methodes ---

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: matterhorn_whymper
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Daniel Fritschi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-02 00:00:00.000000000 Z
+date: 2015-05-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multipart-post
@@ -137,8 +137,11 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- lib/matterhorn/acl.rb
+- lib/matterhorn/dublin_core.rb
 - lib/matterhorn/endpoint.rb
 - lib/matterhorn/endpoint/ingest.rb
+- lib/matterhorn/endpoint/series.rb
 - lib/matterhorn/endpoint/workflow.rb
 - lib/matterhorn/error.rb
 - lib/matterhorn/http_client.rb
@@ -178,7 +181,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: Ruby wrapper around the Matterhorn Endpoint API