app42 0.5.3

data/lib/app42/client/rest_util.rb

@@ -0,0 +1,66 @@
+require 'base64'
+require 'cgi'
+require 'hmac-sha1'
+
+module App42
+  module Client
+    class RestUtil
+
+      #
+      # Finds the current time
+      #
+      # @return time format
+      #
+      #
+      def get_timestamp_utc
+        timestamp = Time.now.utc.strftime("%Y-%m-%dT%H:%M:%S.%LZ")
+        return timestamp.freeze
+      end
+
+      #
+      # It signs the request that has to be sent in the Hmac format.
+      #
+      # @param secretKey
+      # @param params
+      #
+      # @rescue InvalidKeyException
+      #
+      def sign secret_key, params
+        sorted_params =  sort_convert_table(params)
+        signature = compute_hmac(secret_key, sorted_params)
+        signature
+      end
+
+      #
+      # This method sorts all the values that are stored in the table.
+      #
+      # @param table
+      # @return sorted string
+      #
+      #
+      def sort_convert_table(table)
+        sorted_params = ""
+        table.sort {|a,b| a[0] <=> b[0]}.each{ |key, val|
+          sorted_params << key
+          sorted_params << val
+        }
+        sorted_params
+      end
+
+      #
+      # Encoding and decoding of the queries are done using the Hmac Algorithm.
+      #
+      # @param baseString
+      # @param key
+      #
+      # @rescue NoSuchAlgorithmException
+      #
+      def compute_hmac(secret_key, sorted_params)
+        signature =  Base64.encode64(HMAC::SHA1::digest(secret_key, sorted_params)).strip
+        computed_hmac = CGI.escape(signature)
+        computed_hmac
+      end
+
+    end
+  end
+end

data/lib/app42/command/app.rb

@@ -0,0 +1,194 @@
+
+require 'fileutils'
+require 'app42/command/base'
+require 'terminal-table'
+
+module App42
+  module Command
+    class App < Base
+
+      # will collect all required attributes for new VM spawn
+      def setup_infra
+        app_name = get_app_name_and_check_app_url_availability
+        vm_type = get_vm_types
+        iaas = get_iaas_providers
+        app_name, source_url = get_app_source app_name, iaas, vm_type
+      end
+
+      # will collect all required attributes for app deploy
+      def deploy
+        @options[:name] = get_app_name if @options[:name].nil?
+        response = interactive_get 'info', 'app/uploadtypes' if is_app_exist? @options[:name]
+        app_source_type = response['sourceTypes']
+         
+        if response['sourceTypes'].count > 1
+          # TODO, for future release
+          # get_git_url
+        else
+          status = get_binary_url @options[:name]
+        end
+        exit! if status
+      end
+
+      # @param app_name
+      # @return binary
+      # @return deployment path
+      #
+      def get_binary_url app_name
+        app_source, source_url = collect_app_source app_name
+        status = upload_binary app_name, app_source, source_url
+        return status
+      end
+
+      #
+      # @param app_name
+      # @param iaas
+      # @param vm_type
+      # @return host name
+      #
+      def collect_vm_details app_name, iaas, vm_type
+        runtime = get_runtime
+        framework = get_framework iaas, vm_type, runtime
+        webserver = get_webserver iaas, vm_type, runtime, framework
+        os = get_os_for_app iaas, vm_type, runtime, framework, webserver
+        # FIXME, may be configure out later
+        # instance = get_instance 'new_vm'
+        vmconfig = get_vmconfig vm_type, iaas
+        setup_infra_res = App42::Command::Base.new.create_infrastructure app_name, iaas, vm_type, runtime, framework, webserver, os, vmconfig
+        exit! if setup_infra_res
+      end
+
+      #
+      # @param deployment path
+      # @param app_name
+      # @return true/SystemExit
+      #
+      def is_binary_exist? source_url, app_name
+        path = escape_path(source_url)
+        app_file_name = nil
+        @binary_retry ||= 1
+        no_of_file = []
+        Dir["#{path}/*"].collect {|f| app_file_name = f and no_of_file << f  if f.include?('.zip') || f.include?('.war') || f.include?('.tar.gz') || f.include?('.gzip') }
+        if no_of_file.count > 1
+          message "#{Message::MORE_THAN_ONE_BINARY}", true, 'red'
+          app_file_name = input "Please Select Binary", no_of_file, true
+        elsif app_file_name.nil?
+          message "#{Message::NO_BINARY}", true, 'red'
+          exit! if (@binary_retry +=1 ) >= 4
+          get_binary_url app_name
+        end
+        return app_file_name
+      end
+
+      #
+      # ask existing app url for deploy
+      #
+      def ask_existing_app_url
+        input "Enter App URL", [], true
+      end
+
+      # @param app_source_url
+      def ask_app_source app_source_type
+        input "Choose Source Type", app_source_type, true
+      end
+
+      #
+      # @param binary/git
+      # @return path
+      #
+      def get_source_path app_source
+        path = ask(Paint["#{app_source.capitalize} Deployment Path", :cyan])
+        return path.strip 
+      end
+
+      #
+      # collect git URL from user
+      #
+      def get_git_url(prompt = Paint["Deployment Path?", :cyan])
+        ask(prompt) {|q| q.each = true}
+      end
+      
+      #
+      # Will scale app by no of instance
+      #
+      def scale
+        @options[:name] = get_app_name if @options[:name].nil?
+        instance = get_instance __method__ if is_app_exist? @options[:name]
+        scale_or_descal_res = scale_or_descale_app __method__, instance, @options[:name]
+        exit! if scale_or_descal_res
+      end
+
+      #
+      # Will descale app by no of instance
+      #
+      def descale
+        @options[:name] = get_app_name if @options[:name].nil?
+        instance = get_instance __method__ if is_app_exist? @options[:name]
+        scale_or_descal_res = scale_or_descale_app __method__, instance, @options[:name]
+        exit! if scale_or_descal_res
+      end
+
+      # app42 start
+      #
+      # will start the app, return true or error code/message
+      #
+      def start
+        @options[:name] = get_app_name if @options[:name].nil?
+        app_operation_req = app_operation __method__, @options[:name] if is_app_exist? @options[:name]
+        exit! if app_operation_req
+      end
+
+      # app42 stop
+      #
+      # will stop the app, return true or error code/message
+      #
+      def stop
+        @options[:name] = get_app_name if @options[:name].nil?
+        app_operation_req = app_operation __method__, @options[:name] if is_app_exist? @options[:name]
+        exit! if app_operation_req
+      end
+
+      # app42 start
+      #
+      # will restart the app, return true or error code/message
+      #
+      def restart 
+        @options[:name] = get_app_name if @options[:name].nil?
+        app_operation_req = app_operation __method__, @options[:name] if is_app_exist? @options[:name]
+        exit! if app_operation_req
+      end
+
+      #
+      # will delete the app, return true or error code/message
+      #
+      def delete
+        @options[:name] = get_app_name if @options[:name].nil?
+        app_operation_req = app_operation __method__, @options[:name] if is_app_exist? @options[:name]
+        exit! if app_operation_req
+      end
+
+      #
+      # List deployed applications
+      #
+      def apps
+        response = build_get_request params, 'app', nil
+        rows, rows_header_final, rows_header = [], [], nil
+        unless response['apps'].nil? 
+          response['apps'].each do |e|
+            rows_header = e.keys 
+            rows << e.values
+          end
+        else
+          message "#{Message::NO_APP}", true, 'red'
+          exit!  
+        end   
+        
+        rows_header.map { |e| rows_header_final << camel_case_to_whitespace(e) }
+
+        table = Terminal::Table.new  :title => Paint["=== My Apps ===", :green], :headings => rows_header_final, :rows => rows
+        puts table
+      end
+
+    end
+  end 
+end

data/lib/app42/command/authorize.rb

@@ -0,0 +1,29 @@
+
+module App42::Command
+  class Auth
+    class << self
+
+      include App42::Command::UserToken
+      include App42::Base::Util
+
+      # @return [TRUE/FALSE]
+      def logged_in?
+        check_key_file?
+      end
+
+      def is_authorize?(api_key, secret_key) 
+        if api_key.nil? || secret_key.nil?
+          message "#{Message::ADD_KEY}", true, 'red'
+          puts App42::Base::Help.addKeys
+          exit!
+        elsif api_key.size == 1 || secret_key.size == 1 
+          message "#{Message::WRONG_KEY}", true, 'red'
+          puts App42::Base::Help.add
+          exit!
+        end
+      end
+
+    end
+
+  end
+end

data/lib/app42/command/base.rb

@@ -0,0 +1,660 @@
+
+require 'app42/command/user_key'
+require "interact/progress"
+require 'highline'
+require "interact"
+
+module App42
+  module Command
+    class Base
+
+      include App42::Command::UserToken
+      include App42::Base::Util
+      include App42::Base::HttpHelper
+      include Interactive
+      include Interact::Progress
+
+      # @return
+      # dup argument to get a non-frozen string
+      def initialize(options={} )
+        @options = options.dup
+        @connection = App42::Client::App42RestClient.new HOST
+        @api_key, @secret_key = get_keys if check_key_file?
+        App42::Command::Auth.is_authorize?(@api_key, @secret_key)
+        @host = HOST
+      end
+
+      # collect application name from user
+      # if application name will not available
+      # User can try 3 more times with different application name
+      def get_app_name_and_check_app_url_availability
+        @aa_retry ||= 1
+        exit! if (@aa_retry += 1 ) >= 5
+        app_name = get_app_name 
+        available = app_url_availability app_name
+        return available if available
+      end      
+
+      # get supported virtual machine type by app42paas
+      def get_vm_types
+        vm_type = App42::Command::Config.new.get_vm_type
+        vm_type_array = vm_type['deploymentType'].map(&:capitalize)
+        input "Select Virtual Machine Type", vm_type_array, true
+      end
+      
+      # @return iaas providers
+      def get_iaas_providers
+        iaas_provider_hash = {}
+        iaas_providers = App42::Command::Config.new.get_iaas_provider
+
+        iaas_providers['iaas'].select {|each_iaas| iaas_provider_hash["#{each_iaas['id']}"] = each_iaas['name'] + ' ' + each_iaas['zone']}
+        iaas = input "Select IaaS Provider", iaas_provider_hash.values, true
+
+        iaas_provider_id = nil
+        iaas_provider_hash.each_pair{|ip| iaas_provider_id = ip[0] if ip[1] == iaas}
+        return iaas_provider_id
+      end
+
+      # collect remaining vm configuration details from user
+      def get_app_source app_name, iaas, vm_type
+        collect_vm_details app_name, iaas, vm_type
+      end
+
+      # Ask application name from user and
+      # will wait for user response (user will enter application name)
+      def get_app_name(prompt = Paint['Application Name', :cyan])
+        app_name = ask(prompt) {|q| q.each = true}
+        valid_app_name = validate_app_and_service_name "App name", app_name.strip
+        valid_app_name ? (return valid_app_name) : get_app_name
+      end
+
+      # get supported runtime by app42paas
+      def get_runtime
+        runtime_hash = {}
+        runtimes = App42::Command::Config.new.get_runtimes
+        
+        runtimes['runtimes'].select {|each_rt| runtime_hash["#{each_rt['id']}"] = each_rt['name'] + ' ' + each_rt['version']}
+        rt = input "Select Runtime", runtime_hash.values, true
+        
+        rt_id = nil
+        runtime_hash.each_pair{|r| rt_id = r[0] if r[1] == rt}
+        return rt_id
+      end
+
+      # get supported frameworks
+      def get_framework iaas, vm_type, rt
+        framework_hash = {}
+        frameworks = App42::Command::Config.new.get_frameworks iaas, vm_type, rt
+
+        frameworks['frameworks'].select {|each_fw| framework_hash["#{each_fw['id']}"] = each_fw['name'] + ' ' + each_fw['version']}
+        framework = input "Select Framework", framework_hash.values, true
+        
+        framework_id = nil
+        framework_hash.each_pair{|f| framework_id = f[0] if f[1] == framework}
+        return framework_id
+      end
+
+      # get supported webserver
+      def get_webserver iaas, vm_type, rt, framework
+        webserver_hash = {}
+        webservers = App42::Command::Config.new.get_webservers( iaas, vm_type, rt, framework)
+        
+        webservers['webServer'].select {|each_ws| webserver_hash["#{each_ws['id']}"] = each_ws['name'] + ' ' + each_ws['version']}
+        webserver = input "Select Web Server", webserver_hash.values, true
+        
+        webserver_id = nil
+        webserver_hash.each_pair{|ws| webserver_id = ws[0] if ws[1] == webserver}
+        return webserver_id
+      end
+
+      # get supported operating system for app
+      def get_os_for_app iaas, vm_type, rt, framework, webserver
+        os_hash = {}
+        operating_sys = App42::Command::Config.new.get_operating_sys_for_app( iaas, vm_type, rt, framework, webserver)
+        
+        if operating_sys['osDetail'].length > 1
+          operating_sys['osDetail'].select {|each_os| os_hash["#{each_os['id']}"] = each_os['name'] + ' ' + each_os['version']}        
+          os = input "Select Operating System", os_hash.values, true
+
+          os_id = nil
+          os_hash.each_pair{|o| os_id = o[0] if o[1] == os} 
+          return os_id
+        else
+          return operating_sys['osDetail'][0]['id'] 
+        end
+      end
+
+      # get supported operating system for service
+      def get_os_for_service iaas, vm_type, service
+        os_hash = {}
+        operating_sys = App42::Command::Config.new.get_operating_sys_for_service( iaas, vm_type, service)
+        
+        if operating_sys['osDetail'].length > 1
+          operating_sys['osDetail'].select {|each_os| os_hash["#{each_os['id']}"] = each_os['name'] + ' ' + each_os['version']}        
+          os = input "Select Operating System", os_hash.values, true
+
+          os_id = nil
+          os_hash.each_pair{|o| os_id = o[0] if o[1] == os} 
+          return os_id
+        else
+          return operating_sys['osDetail'][0]['id'] 
+        end
+      end
+
+      # get supported vm configuration by app42paas
+      def get_vmconfig vm_type, iaas
+        vmconfig_hash = {}
+        vmconfig = App42::Command::Config.new.get_vmconfig(vm_type, iaas)
+        
+        vmconfig['vmconfig'].select {|each_vmcf| vmconfig_hash["#{each_vmcf['id']}"] = each_vmcf['memory'] + ' ' + each_vmcf['memoryUnit']}        
+        vm_cf = input "Memory Limit", vmconfig_hash.values, true
+        
+        vm_cf_id = nil
+        vmconfig_hash.each_pair{|vmcf| vm_cf_id = vmcf[0] if vmcf[1] == vm_cf}
+        return vm_cf_id
+      end
+
+      # collect type of application source supported by app42paas
+      def collect_app_source app_name 
+        app_source = 'Binary'
+        proceed = ask(
+            Paint["Would you like to deploy from the current directory?", :cyan],
+            :default => true
+        )
+        
+        if proceed
+          source_url = Dir.getwd
+          app_file_name = is_binary_exist? source_url, app_name
+        end
+
+        unless proceed
+          source_url = get_source_path app_source
+          if source_url.include?('.zip') || source_url.include?('.war') || source_url.include?('.tar.gz') || source_url.include?('.gzip')
+            return app_source, source_url   
+          end 
+          app_file_name = is_binary_exist? source_url, app_name
+        end
+        return app_source, app_file_name
+      end
+
+      # private
+      
+      # check app availabilities
+      def app_url_availability app_name
+        query_params = params
+        query_params.store('appName', app_name)
+        
+        response = with_progress(Paint["\nChecking App Name Availability", :yellow]) do |s|
+          build_get_request query_params, 'app', 'availability'
+        end
+
+        if response["success"] 
+          print_new_line 
+          return app_name
+        else
+          message "#{response['description']}", true, 'red'
+          get_app_name_and_check_app_url_availability
+        end
+
+      end
+
+      # check service availabilities
+      def service_name_availability service_name
+        query_params = params
+        query_params.store('serviceName', service_name)
+        
+        response = with_progress(Paint["Checking Service Name Availability", :yellow]) do |s|
+          build_get_request query_params, 'service', 'availability'
+        end
+
+        if response["success"]
+          print_new_line  
+          return service_name
+        else
+          message "#{response['description']}", true, 'red'
+          return nil
+        end
+      end
+
+      # infrastructure setup call
+      def create_infrastructure  app_name, iaas, vm_type, runtime, framework, webserver, os, vmconfig
+        begin
+          body = {'app42' => {"request"=> {
+              "appName"     => app_name,
+              "iaas"        => iaas,
+              "vmType"      => vm_type,
+              "runtime"     => runtime,
+              "framework"   => framework,
+              "webServer"   => webserver,
+              "os"          => os,
+              "vmConfig"    => vmconfig
+          }}}.to_json
+
+          query_params = params
+          query_params.store('body', body)
+       
+          response = with_progress(Paint["Creating Infrastructure", :yellow]) do |s|
+            build_post_request body, query_params, 'app', nil
+          end  
+   
+          if response["success"] == true && response["transactionId"]
+            transaction_success = check_transaction_status response["transactionId"], previous_completed = 0, 'created'
+          end
+      
+          if transaction_success
+            transaction_params = params
+            transaction_params.store('appName', app_name)
+            host_response = build_get_request transaction_params, "app", "#{app_name}"
+          end
+
+          if host_response['success']
+            puts Paint["Default Application Deployed. URL is: #{host_response['appInfo']['appUrl']}", :green]
+            return true 
+          else
+            puts Paint["#{response['description']}", :red]
+          end
+        rescue Interrupt
+          puts Paint[" Command cancelled.", :red]
+          exit!
+        end  
+      end
+
+      # Binary upload call 
+      def upload_binary app_name, app_source, source_url
+        @code_flag ||= 1
+        begin
+          if source_url.include?('.war') || source_url.include?('.zip') || source_url.include?('.tar.gz') || source_url.include?('.gzip')
+            query_params = params
+            query_params.store('appName', app_name)
+            message "#{Message::WAIT_FOR_WHILE}", true, 'green'
+            response = with_progress(Paint["Deploying Application", :yellow]) do |s|
+              @connection.multipart(signature(query_params), resource_url("app", "binary"), query_params, query_params, source_url)
+            end            
+          else
+            body = {'app42' => {"request"=> {
+              "appName"    => app_name,
+              "sourcetype" => app_source,
+              "sourceUrl"  => source_url,
+            }}}.to_json
+
+            query_params = params
+            query_params.store('body', body)
+     
+
+            response = with_progress(Paint["Deploying Application", :yellow]) do |s|
+              build_put_request body, query_params, 'app', 'source'
+            end 
+          end
+
+          if response["success"] == true && response["transactionId"]
+            check_transaction_status response["transactionId"], previous_completed = 0, 'Uploaded'
+          end
+
+          if response['success']
+            exit!
+          else
+            puts Paint["#{response['description']}", :red]
+            exit 1 if ( @code_flag += 1 ) > 3
+            get_binary_url app_name
+          end
+        rescue Interrupt
+          puts Paint[" Command cancelled.", :red]
+          exit!  
+        rescue  Exception => e
+          puts e
+        end
+        return response
+      end
+
+      # It's common methods of app information like app state, info etc.
+      # methods expect +what+ as operation and +app_name+ as Application name
+      def app_information what, app_name
+        query_params = params
+        query_params.store('appName', app_name)
+        begin
+          response = build_get_request query_params, "#{what}", "#{app_name}"
+        rescue  Exception => e
+          puts e
+          exit!
+        end
+        return response
+      end      
+
+      # Scale or descale application by no of instance,
+      # expect +what+ as operation and instance as no of instance
+      def scale_or_descale_app what, instance, app_name
+        begin  
+          body = {'app42' => {"request"=> {
+              'appName'        => app_name,
+              "instanceCount"  => instance
+          }}}.to_json
+
+          query_params = params
+          query_params.store('body', body)
+
+          response = with_progress( Paint[ what.to_s == 'scale' ? "Scaling Application #{app_name} by instance #{instance}" : "Descaling Application #{app_name} by instance #{instance}", :yellow]) do |s|
+            build_post_request body, query_params, "app", what
+          end
+
+          check_transaction_status response["transactionId"], previous_completed = 0, "#{what}d" if response["success"] == true && response["transactionId"]
+          response['success'] ? (return true) : (message "#{response['description']}", true, 'red')
+
+        rescue Interrupt
+          puts Paint[" Command cancelled.", :red]
+          exit!  
+        rescue  Exception => e
+          puts e
+          exit!
+        end
+      end
+
+      # common methods for app42paas config request like runtimes,frameworks etc
+      def interactive_get resource, get_obj
+        begin
+          response = build_get_request params, resource, get_obj
+        rescue  Exception => e
+          puts e
+        end
+        return response
+      end
+
+      # All application operation will take placed like app start, stop etc.
+      # expect +what+ as operation and +app_name+ as application name.
+      def app_operation what, app_name
+        begin
+          if what.to_s == 'stop'
+            response = with_progress(Paint[ "Stopping Application #{app_name}", :yellow]) do |s|
+              body = {'app42' => {"request"=> {
+                "appName" => app_name
+              }}}.to_json
+
+              query_params = params
+              query_params.store('body', body)
+              build_put_request body, query_params, "app", "#{what}" if what.to_s == 'restart' || what.to_s == 'stop' || what.to_s == 'start'      
+            end
+          else
+            response = with_progress(Paint[ what.to_s == 'delete' ? "Deleting Application #{app_name}" : "#{what.capitalize}ing Application #{app_name}", :yellow]) do |s|
+              if what.to_s == 'delete'
+                query_params = params
+                query_params.store('appName', app_name)
+                build_delete_request query_params, "app", "#{app_name}"
+              else
+                body = {'app42' => {"request"=> {
+                  "appName" => app_name
+                }}}.to_json
+
+                query_params = params
+                query_params.store('body', body)
+                build_put_request body, query_params, "app", "#{what}" if what.to_s == 'restart' || what.to_s == 'stop' || what.to_s == 'start'
+              end      
+            end
+          end  
+          
+          if response["success"] == true && response["transactionId"]
+            if what.to_s == 'delete'
+              check_transaction_status response["transactionId"], previous_completed = 0, "#{what}d"
+            elsif what.to_s == 'stop'
+              check_transaction_status response["transactionId"], previous_completed = 0, "#{what}ped"
+            else
+              check_transaction_status response["transactionId"], previous_completed = 0, "#{what}ed"
+            end
+          end
+
+          response['success'] ? (return true) : (message "#{response['description']}", true, 'red')
+        rescue Interrupt
+          puts Paint[" Command cancelled.", :red]
+          exit!
+        end  
+      end
+
+      # create service and get all relevant service information post service creation.
+      #
+      # ==== Parameters
+      # service      = type of service mysql,mongodb etc
+      # service_name = service name provided by user
+      # database     = database name provided by user
+      # vm_type      = shared OR dedicated
+      # iaas         = zone where user want to create service
+      # vmconfig     = virtual machine configuration details
+      # os           = ubuntu OR Window
+      #
+      # ==== return
+      # will display service details in tabular form and
+      # will exist console
+      def create_service service, service_name ,database, vm_type, iaas, vmconfig, os 
+        body = {'app42' => {"request"=> {
+            "service"     => service,
+            "serviceName" => service_name,
+            "vmType"      => vm_type,
+            "database"    => database,
+            "iaas"        => iaas,
+            "vmconfig"    => vmconfig,
+            "os"    => os
+        }}}.to_json 
+
+        query_params = params
+        query_params.store('body', body)
+
+        begin
+          response = with_progress(Paint["Creating Service", :yellow]) do |s|
+            build_post_request body, query_params, 'service', nil
+          end
+        rescue Interrupt
+          puts Paint[" Command cancelled.", :red]
+          exit!
+        end
+
+
+        if response["success"] == true && response["transactionId"]
+          transaction_response = check_transaction_status response["transactionId"], previous_completed = 0, 'created'
+        end
+
+        if transaction_response
+          service_info_params = params
+          service_info_params.store('serviceName', service_name)
+          service_details = build_get_request service_info_params, "service", "#{service_name}"
+        end
+
+        if service_details['success']
+          rows, rows_header_final, rows_header = [], [], nil
+
+          rows_header = service_details['service'].keys 
+          rows << service_details['service'].values
+
+          rows_header.map { |e| rows_header_final << camel_case_to_whitespace(e) } 
+          
+          table = Terminal::Table.new  :title => Paint["=== #{service_name} Details ===", :green], :headings => rows_header_final, :rows => rows
+          puts table
+        else
+          puts Paint["#{response['description']}", :red]
+        end 
+      end
+
+      # delete service, as a
+      #
+      # ==== Parameters
+      # service_name = service name provided by user
+      #
+      # ==== return
+      # true:: if service deleted
+      # OR
+      # ERROR message in case failed
+      def delete_service service_name 
+        begin
+          response = with_progress(Paint["Deleting Service", :yellow]) do |s|
+            query_params = params
+            query_params.store('serviceName', service_name)
+            build_delete_request query_params, "service", "#{service_name}"
+          end
+
+          transaction_success = check_transaction_status response["transactionId"], previous_completed = 0, 'deleted' if response["success"] == true && response["transactionId"]
+
+          response['success'] ? (return true) : (message "#{response['description']}", true, 'red')
+        rescue Interrupt
+          puts Paint[" Command cancelled.", :red]
+          exit!
+        rescue Exception => e
+          puts e  
+        end
+      end
+
+      # reset service password and fetch service latest details
+      #
+      # ==== Parameters
+      # service_name = service name provided by user
+      # old_password = service old password
+      #
+      # ==== return
+      # true:: if reset password successful
+      # OR
+      # ERROR message in case failed
+      def reset_password service_name, old_password
+        begin
+          body = {'app42' => {"request"=> {
+              "serviceName"  => service_name,
+              "password"     => old_password
+          }}}.to_json
+
+          query_params = params
+          query_params.store('body', body)
+          
+          response = with_progress(Paint["Resetting Password", :yellow]) do |s|
+            build_put_request body, query_params, 'service', "password"    
+          end
+
+          if response["success"] == true && response["transactionId"]
+            transaction_response = check_transaction_status response["transactionId"], previous_completed = 0, 'created'
+          end
+
+          if transaction_response
+            service_info_params = params
+            service_info_params.store('serviceName', service_name)
+            service_details = build_get_request service_info_params, "service", "#{service_name}"
+          end
+
+          service_details['success'] ? (return service_details) : (message "#{response['description']}", true , 'red')
+
+        rescue Interrupt
+          puts Paint[" Command cancelled.", :red]
+          exit!
+        rescue Exception => e
+          puts e  
+        end
+      end
+
+      # Bind service to requested source IP and fetch service latest details
+      #
+      # ==== Parameters
+      # service_name = service name provided by user
+      # source_ip    = source IP to which service will get bind
+      # access_time  = time duration user want to bind IP to service
+      #
+      # ==== return
+      # display service bind details in tabular form
+      # OR
+      # ERROR message in case failed
+      def create_service_tunnel service_name, source_ip
+        begin
+          body = {'app42' => {"request"=> {
+              "serviceName" => service_name,
+              "sourceIp" => source_ip
+          }}}.to_json
+
+          query_params = params
+          query_params.store('body', body)
+          
+          response = with_progress(Paint["Binding IP to service", :yellow]) do |s|
+            build_put_request body, query_params, 'service', "bind"    
+          end
+
+          if response["success"] == true && response["transactionId"]
+            transaction_response = check_transaction_status response["transactionId"], previous_completed = 0, 'created'
+          end
+
+          if transaction_response
+            service_info_params = params
+            service_info_params.store('serviceName', service_name)
+            service_tunnel_details = build_get_request service_info_params, "service", "tunnel/#{service_name}"
+          end
+          
+          if service_tunnel_details['success']
+            rows, rows_header_final, rows_header = [], [], nil
+
+            rows_header = service_tunnel_details['service'].keys 
+            rows << service_tunnel_details['service'].values
+
+            rows_header.map { |e| rows_header_final << camel_case_to_whitespace(e) } 
+            
+            table = Terminal::Table.new  :title => Paint["=== #{service_name} Details ===", :green], :headings => rows_header_final, :rows => rows
+            puts table
+          
+          else
+            puts Paint["#{response['description']}", :red]
+          end
+        rescue Interrupt
+          puts Paint[" Command cancelled.", :red]
+          exit!
+        rescue Exception => e
+          puts e  
+        end
+      end
+
+      # Unbind service to requested source IP
+      #
+      # ==== Parameters
+      # service_name = service name provided by user
+      # source_ip    = source IP to which service will get bind
+      #
+      # ==== return
+      # display service bind details in tabular form
+      # OR
+      # ERROR message in case failed
+      def delete_service_tunnel service_name, source_ip
+        begin
+          body = {'app42' => {"request"=> {
+              "serviceName" => service_name,
+              "sourceIp" => source_ip
+          }}}.to_json
+
+          query_params = params
+          query_params.store('body', body)
+          
+          response = with_progress(Paint["Unbinding IP to service", :yellow]) do |s|
+            build_put_request body, query_params, 'service', "unbind"    
+          end
+
+          if response["success"] == true && response["transactionId"]
+            transaction_response = check_transaction_status response["transactionId"], previous_completed = 0, 'created'
+            return true
+          end
+        rescue Interrupt
+          puts Paint[" Command cancelled.", :red]
+          exit!
+        rescue Exception => e
+          puts e  
+        end
+      end     
+      
+      #
+      # return no of instance
+      #
+      def get_instance obj
+        instance = @options[:instance] if @options[:instance]
+        unless instance
+          instance = nil
+          instance = ask Paint[ obj == 'new_vm' ?  "No of instances you want?" : "#{obj.capitalize} by instance(s)", :cyan]
+
+        end
+        
+        instance_count = number_valid? instance 
+
+        if instance_count
+          return instance_count
+        else
+          message "#{Message::NOT_A_VALID_NUM}", true, 'red'
+          get_instance obj
+        end
+      end
+    end
+  end
+end