mtncloud-cli 1.0.0

data/lib/mtncloud/morpkg.rb

@@ -0,0 +1,119 @@
+require 'zip'
+
+module MtnCloud
+
+  # A module for building .morpkg files
+  module Morpkg
+
+    # parse the manifest json data for a package source directory
+    def self.parse_package_manifest(source_directory)
+      source_directory = File.expand_path(source_directory)
+      manifest_filename = File.join(source_directory, "package-manifest.json")
+      if !File.exist?(manifest_filename)
+        raise "Package manifest file not found: #{manifest_filename}"
+      end
+      manifest = JSON.parse(File.read(manifest_filename))
+      return manifest
+    end
+
+    # write a .morpkg file for a package source directory
+    # validates manifest data
+    # default outfile is code-version.morpkg
+    # returns outfile (filename) or raises exception
+    def self.build_package(source_directory, outfile=nil, do_overwrite=false)
+      source_directory = File.expand_path(source_directory)
+      manifest = self.parse_package_manifest(source_directory)
+      code = manifest["code"]
+      version = manifest["version"]
+      org = manifest["org"] || manifest["organization"]
+      type = manifest["type"]
+      if code.nil? || code.empty?
+        raise "Package manifest data missing: code"
+      end
+      if version.nil? || version.empty?
+        raise "Package manifest data missing: version"
+      end
+      # if org.nil? || org.empty?
+      #   raise "Package manifest data missing: org"
+      # end
+      # if type.nil? || type.empty?
+      #   raise "Package manifest data missing: type"
+      # end
+      if outfile.nil? || outfile.empty?
+        # outfile = "#{orig_dir}/#{type}-#{code}-#{version}.morpkg"
+        # outfile = File.join(File.dirname(source_directory), "#{type}-#{code}-#{version}.morpkg")
+        outfile = File.join(File.dirname(source_directory), "#{code}-#{version}.morpkg")
+      elsif File.directory?(outfile)
+        outfile = File.join(outfile, "#{code}-#{version}.morpkg")
+      end
+      if Dir.exist?(outfile)
+        raise "Invalid package target. #{outfile} is the name of an existing directory."
+      end
+      if File.exist?(outfile)
+        if do_overwrite
+          # don't delete, just overwrite.
+          # File.delete(outfile)
+        else
+          raise "Invalid package target. File already exists: #{outfile}"
+        end
+      end
+      # build directories if needed
+      if !Dir.exist?(File.dirname(outfile))
+        Dir.mkdir(File.dirname(outfile))
+      end
+
+      # write the .morpkg file and return filename
+      zf = ZipFileGenerator.new(source_directory, outfile)
+      zf.write()
+      
+      return outfile
+    end
+
+    # This is a simple example which uses rubyzip to
+    # recursively generate a zip file from the contents of
+    # a specified directory. The directory itself is not
+    # included in the archive, rather just its contents.
+    #
+    # Usage:
+    #   directoryToZip = "/tmp/input"
+    #   outputFile = "/tmp/out.zip"
+    #   zf = ZipFileGenerator.new(directoryToZip, outputFile)
+    #   zf.write()
+    class ZipFileGenerator
+
+      # Initialize with the directory to zip and the location of the output archive.
+      def initialize(inputDir, outputFile)
+        @inputDir = inputDir
+        @outputFile = outputFile
+      end
+
+      # Zip the input directory.
+      def write()
+        entries = Dir.entries(@inputDir); entries.delete("."); entries.delete("..")
+        io = Zip::File.open(@outputFile, Zip::File::CREATE);
+        writeEntries(entries, "", io)
+        io.close();
+      end
+
+      # A helper method to make the recursion work.
+      private
+      def writeEntries(entries, path, io)
+
+        entries.each { |e|
+          zipFilePath = path == "" ? e : File.join(path, e)
+          diskFilePath = File.join(@inputDir, zipFilePath)
+          puts "Deflating " + diskFilePath # remove me
+          if  File.directory?(diskFilePath)
+            io.mkdir(zipFilePath)
+            subdir =Dir.entries(diskFilePath); subdir.delete("."); subdir.delete("..")
+            writeEntries(subdir, zipFilePath, io)
+          else
+            io.get_output_stream(zipFilePath) { |f| f.puts(File.open(diskFilePath, "rb").read())}
+          end
+        }
+      end
+
+    end
+
+  end
+end

data/lib/mtncloud/rest_client.rb

@@ -0,0 +1,104 @@
+require 'rest-client'
+require 'uri'
+
+module MtnCloud
+  # A wrapper around rest_client so we can more easily deal with passing options (like turning on/off SSL verification)
+  class RestClient
+
+    class << self
+
+      def user_agent
+        if !defined?(@user_agent) || @user_agent.nil?
+          begin
+            @user_agent = "mtncloud-cli #{MtnCloud::Cli::VERSION}"
+            @user_agent = "#{@user_agent} (#{::RestClient::Platform.architecture}) #{::RestClient::Platform.ruby_agent_version}"
+          rescue
+          end
+        end
+        return @user_agent
+      end
+
+      def execute(options)
+        default_opts = {}
+        # only read requests get default 30 second timeout.
+        if options[:method] == :get || options[:method] == :head
+          default_opts[:timeout] = 30
+        end
+        opts = default_opts.merge(options)
+        unless ssl_verification_enabled?
+          opts[:verify_ssl] = OpenSSL::SSL::VERIFY_NONE
+        end
+
+        opts[:headers] ||= {}
+        opts[:headers][:user_agent] ||= self.user_agent
+
+        # serialize params ourselves, this way we get arrays without the [] suffix
+        params = nil
+        if opts[:params] && !opts[:params].empty?
+          params = opts.delete(:params)
+        elsif opts[:headers] && opts[:headers][:params]
+          # params inside headers for restclient reasons..
+          params = opts[:headers].delete(:params)
+        elsif opts[:query] && !opts[:query].empty?
+          params = opts.delete(:query)
+        end
+        query_string = params
+        if query_string.respond_to?(:map)
+          if options[:grails_params] != false
+            query_string = grails_params(query_string)
+          end
+          query_string = URI.encode_www_form(query_string)
+        end
+        # grails expects dot notation in body params
+        if opts[:method] == :post || opts[:method] == :put
+          if opts[:headers]['Content-Type'].nil? || opts[:headers]['Content-Type'] == 'application/x-www-form-urlencoded' || opts[:headers]['Content-Type'] == 'multipart/form-data'
+            if opts[:payload].respond_to?(:map)
+              if opts[:grails_params] != false
+                # puts "grailsifying it!"
+                opts[:payload] = grails_params(opts[:payload])
+              end
+            end
+          end
+        end
+        if query_string && !query_string.empty?
+          opts[:url] = "#{opts[:url]}?#{query_string}"
+        end
+
+        ::RestClient::Request.execute opts
+      end
+
+      def post(url, payload)
+        execute url: url, payload: payload, method: :post
+      end
+
+      def ssl_verification_enabled?
+        begin
+          @@ssl_verification_enabled.nil? ? true : @@ssl_verification_enabled
+        rescue
+          @@ssl_verification_enabled = true
+        end
+      end
+
+      def enable_ssl_verification=(verify)
+        @@ssl_verification_enabled = verify
+      end
+
+      def grails_params(data, context=nil)
+        params = {}
+        data.each do |k,v|
+          if v.is_a?(Hash)
+            params.merge!(grails_params(v, context ? "#{context}.#{k.to_s}" : k))
+          else
+            if context
+              params["#{context}.#{k.to_s}"] = v
+            else
+              params[k] = v
+            end
+          end
+        end
+        return params
+      end
+
+    end
+  end
+end

data/lib/mtncloud/routes.rb

@@ -0,0 +1,304 @@
+# Routes is a module to provide a way to look up routes in the MTN Cloud UI.
+# Examples:
+#   Routes.lookup("users") == "/admin/users"
+#   Routes.lookup("instances") == "/provisioning/instances"
+#
+#   puts "All routes", MtnCloud::Routes.routes
+#
+module MtnCloud::Routes
+
+  # A static site map for the MTN Cloud UI.
+  # todo: move to YAML or load from api
+  SITE_MAP = {
+    operations: {
+      dashboard: {},
+      reports: {},
+      analytics: {},
+      guidance: {},
+      wiki: {},
+      budgets: {},
+      invoices: {},
+      usage: {},
+      approvals: {},
+      activity: {},
+      alarms: {},
+    },
+    provisioning: {
+      instances: {},
+      apps: {},
+      catalog: {},
+      jobs: {},
+      executions: {},
+      code: {
+        respositories: {},
+        deployments: {},
+        # integrations: {}, # Integrations
+      },
+    },
+    library: {
+      automation: [
+        "#!tasks",
+        "#!workflows",
+        "#!thresholds",
+        "#!power-schedules",
+        "#!execute-schedules",
+      ],
+      blueprints: [
+        "#instance-types",
+        "#!instance-type-layouts",
+        "#!container-types",
+        "#!app-templates", # App Blueprints (blueprints)
+        "#!catalog-items",
+        "#!compute-type-layouts", # Cluster Layouts
+        "#!compute-type-packages", # Cluster Packages
+      ],
+      :'virtual-images' => {},
+      options: [
+        "#!forms", # Forms
+        "#!option-types", # Inputs
+        "#!option-type-lists", # Option Lists
+      ],
+      templates: [
+        "#!specs",
+        "#!files",
+        "#!scripts",
+        "#!security-specs",
+      ],
+      services: {}, # Integrations
+
+    },
+    infrastructure: {
+      groups: {},
+      clouds: {},
+      clusters: {},
+      servers: {}, # Hosts (still used for loading by id)
+      inventory: [ # Compute
+        "#!hosts",
+        "#!virtual-machines",
+        "#!containers",
+        "#!resources",
+        "#!bare-metal",
+      ],
+      networks: {},
+      :'load-balancers' => {},
+      storage: {
+        buckets: {},  
+        shares: {},  # File Shares
+        volumes: {},  
+        :'data-stores' => {}, # ugh, should be datastores
+        servers: {}, # Storage Servers
+      },
+      trust: [
+        "#!credentials",
+        "#!certificates",
+        "#!keypairs",
+        "#!services",
+      ],
+      boot: [
+        "#!mappings",
+        "#!boot-menus",
+        "#!answerfiles",
+        "#!boot-images",
+        "#!macs",
+      ],
+    },
+    backups: {
+      list: {},
+      show: {},
+      jobs: {},
+      history: [
+        "#!restores",
+      ],
+      services: {}
+    },
+    monitoring: {
+      status: {},
+      logs: {},
+      apps: {},
+      checks: {},
+      groups: {},
+      incidents: {},
+      contacts: {},
+      :'alert-rules' => {}, 
+    },
+    tools: {
+      cypher: {},
+      archives: {
+        buckets: {},
+      },
+      :'image-builder' => {},
+      :migrations => {},
+      :vdi => {},
+    },
+    admin: {
+      accounts: {}, # Tenants
+      :'service-plans' => [
+        "#!prices",
+        "#!pricesets"
+      ],
+      roles: {},
+      users: {},
+      :'user-groups' => {},
+      integrations: {},
+      policies: {},
+      health: ["logs"],
+      settings: [
+        "#!appliance",
+        "#!whitelabel",
+        "provisioning",
+        "monitoring",
+        "backups",
+        "logs",
+        "#!guidance",
+        "environments",
+        "software-licenses",
+        "#!license",
+        "#!utilities"
+      ],
+    },
+    :'user-settings' => {}, # User Settings (Profile)
+  } unless defined?(SITE_MAP)
+
+  # A list of routes generated from the site map and cached
+  @@routes = nil
+  
+  # @return an array of well known MTN Cloud UI routes.
+  def self.routes
+    if !@@routes
+      @@routes = build_routes(SITE_MAP)
+    end
+    return @@routes
+  end
+
+  # lookup a route in the mtncloud UI
+  # @param path [String] The input to lookup a route for eg. "dashboard"
+  # @param id [String] ID indicates the show route is needed for a resource for  cases where it varies ie. backups
+  # @return full path like "/operations/dashboard"
+  def self.lookup(path, id=nil)
+    path = path.to_s
+    if path.start_with?("/")
+      # absolute path is being looked up
+      return path
+    else
+      # todo: make this smarter, regex, case insensitive, etc
+      # find the one with smallest match index
+
+      # map well known aliases
+      case(path.dasherize.pluralize)
+      # when "forms"
+      #   path = "/library/options/#!forms"
+      when "inputs"
+        path = "/library/options/#!option-types"
+      when "option-lists"
+        path = "/library/options/#!option-type-lists"
+      when "backups"
+        path = id ? "/backups/show" : "/backups/list"
+      when "backup-jobs"
+        path = "/backups/jobs"
+      when "backup-results"
+        path = "/backups/history"
+      when "backup-restores", "restores"
+        path = "/backups/history/#!restores"
+      when "servers","hosts","vms","virtual-machines"
+        # actually should be "/infrastructure/inventory" unless id is passed, show route uses /servers though
+        path = "/infrastructure/servers"
+      when "computes", "inventories"
+        path = "/infrastructure/inventory"
+      when "tenants"
+        path = "/admin/accounts"
+      when "appliance-settings"
+        path = "/admin/settings/#!appliance"
+      when "whitelabel-settings"
+        path = "/admin/settings/#!whitelabel"
+      when "provisioning-settings"
+        path = "/admin/settings/#!provisioning"
+      when "monitoring-settings","monitor-settings"
+        path = "/admin/settings/monitoring"
+      when "backup-settings"
+        path = "/admin/settings/backups"
+      when "log-settings"
+        path = "/admin/settings/logs"
+      when "guidance-settings"
+        path = "/admin/settings/#!guidance"
+      when "environments"
+        path = "/admin/settings/environments"
+      when "software-licenses"
+        path = "/admin/settings/software-licenses"
+      when "license","licenses"
+        path = "/admin/settings/#!license"
+      end
+      # todo: this is weird, fix it so "view license matches license before software-licenses without needing the above alias..
+      # dasherize path and attempt to match the plural first
+      plural_path = path.pluralize
+      paths = [path.dasherize]
+      if plural_path != path
+        paths.unshift(plural_path.dasherize)
+      end
+
+      best_route = nil
+      #best_index = nil
+      best_prefix_words = nil
+      paths.each do |p|
+        if best_route.nil?
+          self.routes.each do |it|
+            match_index = it.index(p)
+            if match_index
+              prefix_route = match_index == 0 ? "" : it[0..(match_index-1)]
+              prefix_words = prefix_route.split("/")
+              #if best_index.nil? || match_index < best_index
+              if best_prefix_words.nil? || prefix_words.size < best_prefix_words.size
+                best_route = it
+                #best_index = match_index
+                best_prefix_words = prefix_words
+              end
+            end
+          end
+        end
+      end
+      if best_route
+        return best_route
+      else
+        # no match found
+        return nil
+      end
+    end
+    
+  end
+
+  protected 
+
+  # build_routes constructs an array of routes (paths) 
+  # This traversing the route map recursively and appends paths to output
+  # @params route_map [Hash] map of routes
+  # @params context [String] the current content
+  # @params output [Array] the list of route paths being constructed for return
+  # @return array like ["/operations", "/operations/dashboard", "/admin", "/etc"]
+  def self.build_routes(route_map, context="", output = nil)
+    if output.nil?
+      output = []
+    end
+    route_map.each do |k,v|
+      leaf_path = "#{context}/#{k}"
+      output << leaf_path
+      if v.is_a?(Hash)
+        build_routes(v, leaf_path, output)
+      elsif v.is_a?(Array)
+        v.each do |obj|
+          if obj.is_a?(Hash)
+            build_routes(obj, leaf_path, output)
+          elsif obj.is_a?(Symbol) || obj.is_a?(String)
+            # route leaf type not handled
+            output << "#{leaf_path}/#{obj}"
+          else
+            # route leaf type not handled
+          end
+        end
+      else
+        # route leaf type not handled
+      end
+    end
+    return output
+  end
+
+  
+end