ruby_aem 0.9.0

data/lib/ruby_aem/client.rb

@@ -0,0 +1,131 @@
+=begin
+Copyright 2016 Shine Solutions
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+=end
+
+require 'ruby_aem/handlers/file'
+require 'ruby_aem/handlers/html'
+require 'ruby_aem/handlers/json'
+require 'ruby_aem/handlers/simple'
+require 'ruby_aem/handlers/xml'
+require 'ruby_aem/swagger'
+require 'swagger_aem'
+
+module RubyAem
+  # Client class makes Swagger AEM API calls and handles the response as
+  # configured in conf/spec.yaml .
+  class Client
+
+    # Initialise a client.
+    #
+    # @param apis a hash of Swagger AEM client's API instances
+    # @param spec ruby_aem specification
+    # @return new RubyAem::Client instance
+    def initialize(apis, spec)
+      @apis = apis
+      @spec = spec
+    end
+
+    # Make an API call using the relevant Swagger AEM API client.
+    # Clazz and action parameters are used to identify the action, API, and params
+    # from ruby_aem specification, alongside the response handlers.
+    #
+    # @param clazz the class name of the caller resource
+    # @param action the action of the API call
+    # @param info additional information of the API call
+    # @return RubyAem::Result
+    def call(clazz, action, info)
+
+      component = clazz.name.downcase.sub('rubyaem::', '')
+      action_spec = @spec[component]['actions'][action]
+
+      api = @apis[action_spec['api'].to_sym]
+      operation = action_spec['operation']
+
+      params = []
+      required_params = action_spec['params']['required'] || {}
+      required_params.each { |key, value|
+        params.push(value % info)
+      }
+      params.push({})
+      optional_params = action_spec['params']['optional'] || {}
+      optional_params.each { |key, value|
+        add_optional_param(key, value, params, info)
+      }
+
+      base_responses = @spec[component]['responses'] || {}
+      action_responses = action_spec['responses'] || {}
+      responses = base_responses.merge(action_responses)
+
+      begin
+        method = RubyAem::Swagger.operation_to_method(operation)
+        data, status_code, headers = api.send("#{method}_with_http_info", *params)
+        handle(data, status_code, headers, responses, info)
+      rescue SwaggerAemClient::ApiError => err
+        handle(err.response_body, err.code, err.response_headers, responses, info)
+      end
+    end
+
+    # Add optional param into params list.
+    #
+    # @param key optional param key
+    # @param value optional param value
+    # @param params combined list of required and optional parameters
+    # @param info additional information
+    def add_optional_param(key, value, params, info)
+      # if there is no value in optional param spec,
+      # then only add optional param that is set in info
+      if !value
+        if info.key? key.to_sym
+          params[-1][key.to_sym] = info[key.to_sym]
+        end
+      # if value is provided in optional param spec,
+      # then apply variable interpolation the same way as required param
+      else
+        if value.class == String
+          if value == '__FILE__'
+            File.open("#{info[:file_path]}/#{info[:package_name]}-#{info[:package_version]}.zip", 'r') { |file|
+              params[-1][key.to_sym] = file
+            }
+          else
+            params[-1][key.to_sym] = value % info
+          end
+        else
+          params[-1][key.to_sym] = value
+        end
+      end
+    end
+
+    # Handle a response based on status code and a given list of response specifications.
+    # If none of the response specifications contains the status code, a failure result
+    # will then be returned.
+    #
+    # @param data data payload
+    # @param status_code response HTTP status code
+    # @param headers response HTTP headers
+    # @param responses a list of response specifications as configured in conf/spec.yaml
+    # @param info additional information
+    # @return RubyAem::Result
+    def handle(data, status_code, headers, responses, info)
+      if responses.key?(status_code)
+        response_spec = responses[status_code]
+        handler = response_spec['handler']
+        result = Handlers.send(handler, data, status_code, headers, response_spec, info)
+      else
+        result = Result.new('failure', "Unexpected response\nstatus code: #{status_code}\nheaders: #{headers}\ndata: #{data}")
+      end
+    end
+
+  end
+end

data/lib/ruby_aem/config_property.rb

@@ -0,0 +1,53 @@
+=begin
+Copyright 2016 Shine Solutions
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+=end
+
+module RubyAem
+  # ConfigProperty class contains API calls related to managing an AEM config property.
+  class ConfigProperty
+
+    # Initialise a config property
+    #
+    # @param client RubyAem::Client
+    # @param name the property's name
+    # @param type the property's type, e.g. Boolean
+    # @param value the property's value, e.g. true
+    # @return new RubyAem::ConfigProperty instance
+    def initialize(client, name, type, value)
+      @client = client
+      @info = {
+        name: name,
+        type: type,
+        value: value
+      }
+    end
+
+    # Create a new config property.
+    #
+    # @param run_mode AEM run mode: author or publish
+    # @return RubyAem::Result
+    def create(run_mode)
+
+      name = RubyAem::Swagger.property_to_parameter(@info[:name])
+
+      @info[:run_mode] = run_mode
+      @info["#{name}".to_sym] = @info[:value]
+      @info["#{name}_type_hint".to_sym] = @info[:type]
+
+      @client.call(self.class, __callee__.to_s, @info)
+    end
+
+  end
+end

data/lib/ruby_aem/flush_agent.rb

@@ -0,0 +1,65 @@
+=begin
+Copyright 2016 Shine Solutions
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+=end
+
+module RubyAem
+  # FlushAgent class contains API calls related to managing an AEM flush agent.
+  class FlushAgent
+
+    # Initialise a flush agent.
+    #
+    # @param client RubyAem::Client
+    # @param run_mode AEM run mode: author or publish
+    # @param name the flush agent's name, e.g. some-flush-agent
+    # @return new RubyAem::FlushAgent instance
+    def initialize(client, run_mode, name)
+      @client = client
+      @info = {
+        run_mode: run_mode,
+        name: name
+      }
+    end
+
+    # Create or update a flush agent.
+    #
+    # @param title flush agent title
+    # @param description flush agent description
+    # @param dest_base_url base URL of the agent target destination, e.g. http://somedispatcher:8080
+    # @return RubyAem::Result
+    def create_update(title, description, dest_base_url)
+      @info[:title] = title
+      @info[:description] = description
+      @info[:dest_base_url] = dest_base_url
+      @client.call(self.class, __callee__.to_s, @info)
+    end
+
+    # Delete the flush agent.
+    #
+    # @return RubyAem::Result
+    def delete()
+      @client.call(self.class, __callee__.to_s, @info)
+    end
+
+    # Check whether the flush agent exists or not.
+    # If the flush agent  exists, this method returns a success result.
+    # Otherwise it returns a failure result.
+    #
+    # @return RubyAem::Result
+    def exists()
+      @client.call(self.class, __callee__.to_s, @info)
+    end
+
+  end
+end

data/lib/ruby_aem/group.rb

@@ -0,0 +1,101 @@
+=begin
+Copyright 2016 Shine Solutions
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+=end
+
+module RubyAem
+  # Group class contains API calls related to managing an AEM group.
+  class Group
+
+    # Initialise a group.
+    #
+    # @param client RubyAem::Client
+    # @param path the path to group node, e.g. /home/groups/s/
+    # @param name the name of the AEM group, e.g. somegroup
+    # @return new RubyAem::Group instance
+    def initialize(client, path, name)
+      @client = client
+      @info = {
+        path: path,
+        name: name
+      }
+    end
+
+    # Create a new group.
+    #
+    # @return RubyAem::Result
+    def create()
+      if !@info[:path].match(/^\//)
+        @info[:path] = "/#{@info[:path]}"
+      end
+      @client.call(self.class, __callee__.to_s, @info)
+    end
+
+    # Delete the group.
+    #
+    # @return RubyAem::Result
+    def delete()
+      result = find_authorizable_id
+      if result.data
+        @info[:path] = RubyAem::Swagger.path(@info[:path])
+        @client.call(self.class, __callee__.to_s, @info)
+      else
+        result
+      end
+    end
+
+    # Check whether the group exists or not.
+    # If the group exists, this method returns a success result.
+    # Otherwise it returns a failure result.
+    #
+    # @return RubyAem::Result
+    def exists()
+      @info[:path] = RubyAem::Swagger.path(@info[:path])
+      @client.call(self.class, __callee__.to_s, @info)
+    end
+
+    # Set the group's permission.
+    #
+    # @param permission_path the path that the group's permission is to be set against, e.g. /etc/replication
+    # @param permission_csv comma-separated-values of the group's permission, e.g. read:true,modify:true
+    # @return RubyAem::Result
+    def set_permission(permission_path, permission_csv)
+      @info[:permission_path] = permission_path
+      @info[:permission_csv] = permission_csv
+      @client.call(self.class, __callee__.to_s, @info)
+    end
+
+    # Add another group as a member of this group.
+    #
+    # @param member the name of the member group to be added
+    # @return RubyAem::Result
+    def add_member(member)
+      result = find_authorizable_id
+      if result.data
+        @info[:member] = member
+        @client.call(self.class, __callee__.to_s, @info)
+      else
+        result
+      end
+    end
+
+    # Find the group's authorizable ID.
+    #
+    # @return RubyAem::Result
+    def find_authorizable_id()
+      @client.call(self.class, __callee__.to_s, @info)
+    end
+
+  end
+end

data/lib/ruby_aem/handlers/file.rb

@@ -0,0 +1,42 @@
+=begin
+Copyright 2016 Shine Solutions
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+=end
+
+module RubyAem
+  # Response handlers for file payload.
+  module Handlers
+
+    # Handle downloaded file by copying from temporary location to file_path info.
+    # The downloaded file in temporary location will then be deleted.
+    # data, status_code, and headers are all returned from RubyAem::Client call.
+    #
+    # @param data data payload
+    # @param status_code response HTTP status code
+    # @param headers response HTTP headers
+    # @param response_spec response specification as configured in conf/spec.yaml
+    # @param info additional information
+    # @return RubyAem::Result
+    def Handlers.file_download(data, status_code, headers, response_spec, info)
+
+      FileUtils.cp(data.path, "#{info[:file_path]}/#{info[:package_name]}-#{info[:package_version]}.zip")
+      data.delete
+
+      message = response_spec['message'] % info
+
+      RubyAem::Result.new('success', message)
+    end
+
+  end
+end

data/lib/ruby_aem/handlers/html.rb

@@ -0,0 +1,46 @@
+=begin
+Copyright 2016 Shine Solutions
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+=end
+
+require 'nokogiri'
+
+module RubyAem
+  # Response handlers for HTML payload.
+  module Handlers
+
+    # Parse authorizable ID from response body data.
+    # This is used to get the authorizable ID of a newly created user/group.
+    #
+    # @param data data payload
+    # @param status_code response HTTP status code
+    # @param headers response HTTP headers
+    # @param response_spec response specification as configured in conf/spec.yaml
+    # @param info additional information
+    # @return RubyAem::Result
+    def Handlers.html_authorizable_id(data, status_code, headers, response_spec, info)
+
+      html = Nokogiri::HTML(data)
+      authorizable_id = html.xpath('//title/text()').to_s
+      authorizable_id.slice! "Content created #{info[:path]}"
+      info[:authorizable_id] = authorizable_id.sub(/^\//, '')
+
+      status = response_spec['status']
+      message = response_spec['message'] % info
+
+      RubyAem::Result.new(status, message)
+    end
+
+  end
+end

data/lib/ruby_aem/handlers/json.rb

@@ -0,0 +1,96 @@
+=begin
+Copyright 2016 Shine Solutions
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+=end
+
+require 'json'
+
+module RubyAem
+  # Response handlers for JSON payload.
+  module Handlers
+
+    # Handle JSON response payload containing authorizable ID.
+    #
+    # @param data data payload
+    # @param status_code response HTTP status code
+    # @param headers response HTTP headers
+    # @param response_spec response specification as configured in conf/spec.yaml
+    # @param info additional information
+    # @return RubyAem::Result
+    def Handlers.json_authorizable_id(data, status_code, headers, response_spec, info)
+
+      json = JSON.parse(data)
+      authorizable_id = nil
+      if json['success'] == true && json['hits'].length == 1
+        authorizable_id = json['hits'][0]['name']
+        info[:authorizable_id] = authorizable_id
+        message = response_spec['message'] % info
+      else
+        message = "User/Group #{info[:name]} authorizable ID not found"
+      end
+
+      status = response_spec['status']
+
+      result = RubyAem::Result.new(status, message)
+      result.data = authorizable_id
+      result
+    end
+
+    # Handle package JSON payload. Result status is determined directly by success field.
+    #
+    # @param data data payload
+    # @param status_code response HTTP status code
+    # @param headers response HTTP headers
+    # @param response_spec response specification as configured in conf/spec.yaml
+    # @param info additional information
+    # @return RubyAem::Result
+    def Handlers.json_package_service(data, status_code, headers, response_spec, info)
+
+      json = JSON.parse(data)
+
+      status = json['success'] == true ? 'success' : 'failure'
+      message = json['msg']
+
+      RubyAem::Result.new(status, message)
+    end
+
+    # Handle package filter JSON payload.
+    #
+    # @param data data payload
+    # @param status_code response HTTP status code
+    # @param headers response HTTP headers
+    # @param response_spec response specification as configured in conf/spec.yaml
+    # @param info additional information
+    # @return RubyAem::Result
+    def Handlers.json_package_filter(data, status_code, headers, response_spec, info)
+
+      json = JSON.parse(data)
+
+      filter = []
+      json.each do |key, value|
+        if json[key]['root'] != nil
+          filter.push(json[key]['root'])
+        end
+      end
+
+      message = response_spec['message'] % info
+
+      result = RubyAem::Result.new('success', message)
+      result.data = filter
+      result
+
+    end
+
+  end
+end

data/lib/ruby_aem/handlers/simple.rb

@@ -0,0 +1,41 @@
+=begin
+Copyright 2016 Shine Solutions
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+=end
+
+require 'ruby_aem/result'
+
+module RubyAem
+  # Response handlers for no payload.
+  module Handlers
+
+    # Simple handler by returning result that contains status and message as
+    # configured in conf/spec.yaml AS-IS.
+    #
+    # @param data data payload
+    # @param status_code response HTTP status code
+    # @param headers response HTTP headers
+    # @param response_spec response specification as configured in conf/spec.yaml
+    # @param info additional information
+    # @return RubyAem::Result
+    def Handlers.simple(data, status_code, headers, response_spec, info)
+
+      status = response_spec['status']
+      message = response_spec['message'] % info
+
+      RubyAem::Result.new(status, message)
+    end
+
+  end
+end

data/lib/ruby_aem/handlers/xml.rb

@@ -0,0 +1,50 @@
+=begin
+Copyright 2016 Shine Solutions
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+=end
+
+require 'nokogiri'
+
+module RubyAem
+  # Response handlers for XML payload.
+  module Handlers
+
+    # Handle package list XML by removing non-packages data.
+    #
+    # @param data data payload
+    # @param status_code response HTTP status code
+    # @param headers response HTTP headers
+    # @param response_spec response specification as configured in conf/spec.yaml
+    # @param info additional information
+    # @return RubyAem::Result
+    def Handlers.xml_package_list(data, status_code, headers, response_spec, info)
+
+      xml = Nokogiri::XML(data)
+
+      status_code = xml.xpath('//crx/response/status/@code').to_s
+      status_text = xml.xpath('//crx/response/status/text()').to_s
+
+      if status_code == '200' && status_text == 'ok'
+        message = response_spec['message'] % info
+        result = RubyAem::Result.new('success', message)
+        result.data = xml.xpath('//crx/response/data/packages')
+      else
+        result = RubyAem::Result.new('failure', "Unable to retrieve package list, getting status code #{status_code} and status text #{status_text}")
+      end
+
+      result
+    end
+
+  end
+end

data/lib/ruby_aem/node.rb

@@ -0,0 +1,63 @@
+=begin
+Copyright 2016 Shine Solutions
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+=end
+
+module RubyAem
+  # Node class contains API calls related to managing an AEM node.
+  class Node
+
+    # Initialise a node.
+    #
+    # @param client RubyAem::Client
+    # @param path the path to the node, e.g. /apps/system/
+    # @param name the node name, e.g. somenode
+    # @return new RubyAem::Node instance
+    def initialize(client, path, name)
+      @client = client
+      @info = {
+        path: path,
+        name: name
+      }
+
+      @info[:path] = RubyAem::Swagger.path(@info[:path])
+    end
+
+    # Create a new node.
+    #
+    # @param type the node type, e.g. sling:Folder
+    # @return RubyAem::Result
+    def create(type)
+      @info[:type] = type
+      @client.call(self.class, __callee__.to_s, @info)
+    end
+
+    # Delete the node.
+    #
+    # @return RubyAem::Result
+    def delete()
+      @client.call(self.class, __callee__.to_s, @info)
+    end
+
+    # Check whether the node exists or not.
+    # If the node exists, this method returns a success result.
+    # Otherwise it returns a failure result.
+    #
+    # @return RubyAem::Result
+    def exists()
+      @client.call(self.class, __callee__.to_s, @info)
+    end
+
+  end
+end