jcf 0.0.9

data/lib/jcf/cf/base.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require "json"
+require "English"
+require "active_model"
+require "active_model/serializers/json"
+require "active_support/core_ext/hash"
+require "active_support/core_ext/string"
+require "active_support/core_ext/object"
+
+module JCF
+  module CF
+    class Base
+      include ActiveModel::Model
+      include ActiveModel::Serialization
+      include ActiveModel::Validations
+
+      attr_accessor :name, :guid, :relationships, :raw
+
+      validates_presence_of :name, :guid
+
+      def attributes
+        { name: name, guid: guid, relationships: relationships }
+      end
+
+      def initialize(name: nil, guid: nil, relationships: nil)
+        @name = name
+        @guid = guid
+        @relationships = Relationships.new(self, relationships)
+      end
+
+      class << self
+        attr_accessor :endpoint
+
+        def find_by(attrs)
+          objects = all
+          objects.find_all do |obj|
+            # only find by attributes we have and our object has
+            keys = obj.attributes.keys & attrs.keys
+            keys.all? do |key|
+              obj.attributes[key].include? attrs[key]
+            end
+          end
+        end
+
+        def first(attrs)
+          find_by(attrs).first
+        end
+
+        def find(guid)
+          new(guid: guid).populate!
+        end
+
+        def all(params = {})
+          params.compact!
+
+          resources(params: params)
+        end
+
+        def resource_url
+          endpoint || name.demodulize.tableize
+        end
+
+        private
+
+        def resources(params: {})
+          params.compact!
+
+          hash = JCF::CF.curl(resource_url, params: params)
+          populate_objects(hash)
+        end
+
+        def populate_objects(hash)
+          hash[:resources].map! do |object|
+            o = new(
+              guid: object[:guid],
+              name: object[:name],
+              relationships: object[:relationships]
+            )
+            o
+          end
+        end
+      end
+
+      def to_s
+        "#{name} #{guid}"
+      end
+
+      def populate!
+        resource(guid)
+      end
+
+      private
+
+      def resource(guid)
+        object = self.class.all.find { |obj| obj.guid == guid }
+        return object if object
+
+        hash = JCF::CF.curl("#{self.class.resource_url}/#{guid}", params: nil)
+        parse_object(hash)
+      end
+
+      def parse_object(hash)
+        hash[:resources].first if hash[:resources].is_a?(Array)
+
+        hash[:guid]
+        hash[:name]
+        (hash[:relationships] || {})
+        self
+      end
+    end
+  end
+end

data/lib/jcf/cf/metric.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module JCF
+  module CF
+    class Metric < Base
+      attr_accessor :name, :region, :deploy_env, :organization, :organization_guid, :space, :space_guid,
+                    :service_broker_name, :service_broker_guid, :service_offering, :service_plan,
+                    :storage_allocated, :storage_used, :storage_free, :iops, :cpu
+
+      # rubocop:disable Metrics/MethodLength
+      def attributes
+        {
+          name: name,
+          region: region,
+          organization: organization,
+          organization_guid: organization_guid,
+          space: space,
+          space_guid: space_guid,
+          service_broker_name: service_broker_name,
+          service_broker_guid: service_broker_guid,
+          service_offering: service_offering,
+          service_plan: service_plan,
+          storage_used: storage_used,
+          storage_allocated: storage_allocated,
+          storage_free: storage_free,
+          iops: iops,
+          cpu: cpu
+        }
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def to_s
+        "#{name}: used(#{storage_used}) allocated(#{storage_allocated}) free(#{storage_free}) iops(#{iops}) cpu(#{cpu})"
+      end
+    end
+  end
+end

data/lib/jcf/cf/organization.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module JCF
+  module CF
+    class Organization < Base
+    end
+  end
+end

data/lib/jcf/cf/quota.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module JCF
+  module CF
+    class Quota < Base
+      self.endpoint = "organization_quotas"
+    end
+  end
+end

data/lib/jcf/cf/relationships.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module JCF
+  module CF
+    class Relationships
+      include Enumerable
+
+      attr_reader :belongs_to
+
+      def initialize(belongs_to, relationships = {})
+        relationships = {} if relationships.nil?
+        raise ArgumentError, "expects a hash" unless relationships.is_a?(Hash)
+
+        @belongs_to = belongs_to
+        @relationships = convert_to_classes(relationships)
+      end
+
+      def each(&block)
+        @relationships&.each(&block)
+      end
+
+      def inspect
+        @relationships.inspect
+      end
+
+      def relationship?(method_name)
+        klass = get_klass(method_name)
+
+        matches = @relationships.filter_map do |relationship|
+          relationship.instance_of?(klass) ? relationship : nil
+        end.compact
+
+        matches.any?
+      rescue NameError
+        false
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        relationship?(method_name) || super
+      end
+
+      def method_missing(method_name, *args, &block)
+        if relationship?(method_name)
+          klass = get_klass(method_name)
+
+          matches = @relationships.filter_map do |relationship|
+            relationship.instance_of?(klass) ? relationship : nil
+          end
+
+          matches.size == 1 ? matches.first : matches
+        else
+          super
+        end
+      end
+
+      def to_s
+        @relationships.collect do |relationship|
+          "#{relationship.class.name.demodulize}: #{relationship.name || ""} (#{relationship.guid})"
+        end.join(", ")
+      end
+
+      private
+
+      def convert_to_classes(relationships = {})
+        return {} if relationships.nil?
+
+        relationships.collect do |relationship_type, data_hash|
+          klass = get_klass(relationship_type)
+          data = make_array(data_hash[:data])
+
+          data.collect do |d|
+            klass.new(guid: (d || {})[:guid])
+          end.flatten
+        end.flatten
+      end
+
+      def get_klass(method)
+        "JCF::CF::#{method.to_s.singularize.camelize}".constantize
+      end
+
+      def make_array(data)
+        data.is_a?(Array) ? data : [data]
+      end
+    end
+  end
+end

data/lib/jcf/cf/service_broker.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module JCF
+  module CF
+    class ServiceBroker < Base
+    end
+  end
+end

data/lib/jcf/cf/service_instance.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module JCF
+  module CF
+    class ServiceInstance < Base
+    end
+  end
+end

data/lib/jcf/cf/service_offering.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module JCF
+  module CF
+    class ServiceOffering < Base
+    end
+  end
+end

data/lib/jcf/cf/service_plan.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module JCF
+  module CF
+    class ServicePlan < Base
+    end
+  end
+end

data/lib/jcf/cf/space.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module JCF
+  module CF
+    class Space < Base
+    end
+  end
+end

data/lib/jcf/cf/user.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module JCF
+  module CF
+    class User < Base
+      attr_accessor :username, :guid, :presentation_name, :raw
+
+      validates_presence_of :username, :guid, :presentation_name
+
+      def attributes
+        { username: username, guid: guid, presentation_name: presentation_name }
+      end
+
+      def initialize(username: nil, guid: nil, presentation_name: nil)
+        super()
+        @username = username
+        @guid = guid
+        @presentation_name = presentation_name
+      end
+
+      def self.populate_objects(hash)
+        hash[:resources].map! do |object|
+          o = new(
+            guid: object[:guid],
+            username: object[:username],
+            presentation_name: object[:presentation_name]
+          )
+          o
+        end
+      rescue NoMethodError
+        puts "object is #{hash[:resources]}"
+      end
+    end
+  end
+end

data/lib/jcf/cf.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module JCF
+  module CF
+    def self.curl(endpoint, params: {})
+      params[:per_page] ||= 5000 if params
+      url = sanitize_url(endpoint, params)
+
+      response = do_curl(url)
+
+      raise(JCF::CLI::NotLoggedInError, response) if response == "\n" || response.include?("FAILED")
+
+      JSON.parse(response).deep_symbolize_keys
+    end
+
+    def self.sanitize_url(endpoint, params)
+      url = endpoint.dup
+      url << "?#{params.to_query}" if params && params != {}
+      url
+    end
+
+    def self.do_curl(url)
+      JCF.cache.get_or_set("cf curl \"/v3/#{url}\"".parameterize) do
+        puts "cf curl \"/v3/#{url}\"" if ENV["DEBUG"]
+        `cf curl \"/v3/#{url}\"`
+      end
+    end
+  end
+end

data/lib/jcf/cli/command.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "dry/cli"
+require "active_support/core_ext/string/inflections"
+
+module JCF
+  module CLI
+    class Command < Dry::CLI::Command
+      module Output
+        attr_reader :out, :err, :formatter
+
+        def call(*args, **opts)
+          @out = opts[:output] ? File.new(opts[:output], "w") : $stdout
+          @err = $stderr
+          output = opts[:format]
+          @output_file = opts[:output]
+          @formatter = OutputFormatters.formatter(output)
+
+          super(*args, **opts)
+        ensure
+          @out.close if @out && @out != $stdout
+        end
+      end
+
+      # mix in the global options
+      def self.inherited(klass)
+        super
+        klass.option :format, aliases: ["--format"], default: "text", values: %w[text json csv], desc: "Output format"
+        klass.option :output, aliases: ["--output"], desc: "Output file"
+
+        klass.prepend(Output)
+      end
+    end
+  end
+end

data/lib/jcf/cli/commands/cf/metrics.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+# TODO: THIS IS A PROTOTYPE, REDO THIS INTO SOMETHING LESS SCRIPTY
+
+require "shellwords"
+require_relative "../../errors"
+require "active_support"
+require "active_support/core_ext/numeric/conversions"
+require "filesize"
+require "concurrent"
+
+module JCF
+  module CLI
+    module Commands
+      module CF
+        class Metrics < Command
+          argument :env, required: true, values: %w[dev01 dev02 dev03 dev04 dev05 staging prod prod-lon],
+                         desc: "Choose an environment"
+          argument :type, required: true, values: %w[postgres aws-s3-bucket],
+                          desc: "Choose a service instance type to query", default: "postgres"
+
+          option :org, aliases: ["-o"], required: true, type: :string,
+                       desc: "Choose an organization (can be multiple comma-separated)"
+          option :name, aliases: ["-n"], type: :string, desc: "Choose a service instance name"
+
+          def call(*_args, **options)
+            validate_options(options)
+            orgs = options[:org].include?(",") ? options[:org].split(",") : [options[:org]]
+
+            orgs.each do |org|
+              org_guid = organizations.find { |o| o.name == org }.guid
+              err.puts "Found org guid: #{org_guid}"
+
+              offering_guid = service_offerings.find { |s| s.name == options[:type] }&.guid
+              err.puts "Found offering guid: #{offering_guid}"
+
+              unless offering_guid
+                err.puts "No offerings found for type #{options[:type]}"
+                exit(1)
+              end
+
+              # find the plans for those gatherings
+              plan_guids = service_plans.find_all do |plan|
+                plan.relationships.service_offering.guid == offering_guid
+              end.collect(&:guid)
+              err.puts "Found plan guids: #{plan_guids.count}"
+
+              # look up the instances that match the plans and org
+              # "/v3/service_instances?organization_guids=${org_guids}&service_plan_guids=${plan_guids}"
+              instances = JCF::CF::ServiceInstance.all(
+                organization_guids: org_guid,
+                service_plan_guids: plan_guids.join(",")
+              )
+              instances.select! { |i| i.name.include? options[:name] } if options[:name]
+              err.puts "Found instances: #{instances.count}"
+
+              cw = JCF::AWS::CloudWatch.new
+              values = []
+
+              Thread.abort_on_exception = true
+              # use a the number of processors as the number of threads
+              instances.each_slice(Concurrent.processor_count) do |slice|
+                slice.collect do |instance|
+                  service_plan = instance.relationships.service_plan.populate!
+                  service_offering = service_plan.relationships.service_offering.populate!
+                  service_broker = service_offering.relationships.service_broker.populate!
+                  # puts "Getting metrics for #{instance.name}"
+                  # puts "service_plan: #{service_plan.name}"
+                  # puts "service_offering: #{service_offering.name}"
+                  # puts "service_broker: #{service_broker.name}"
+                  # return nil
+
+                  Thread.new do
+                    m = JCF::CF::Metric.new
+                    m.name = (instance.name || "")
+                    err.puts "Getting metrics for #{m.name}"
+                    m.region = ENV["AWS_REGION"]
+                    m.deploy_env = options[:env]
+                    m.organization = org
+                    m.organization_guid = org_guid
+                    space = spaces.find { |s| s.guid == instance.relationships.space.guid }
+                    m.space = space.name
+                    m.space_guid = space.guid
+                    m.service_broker_name = service_broker.name
+                    m.service_broker_guid = service_broker.guid
+                    m.service_offering = service_offering.name
+                    m.service_plan = service_plan.name
+                    if service_offering.name == "postgres"
+                      m.storage_used = to_gb(cw.rds_storage_used(name: rds_guid(instance.guid)) || "")
+                      m.storage_allocated = to_gb(cw.storage_allocated(name: rds_guid(instance.guid)) || "")
+                      m.storage_free = to_gb(cw.storage_free(name: rds_guid(instance.guid)) || "")
+                      m.iops = (cw.iops(name: rds_guid(instance.guid)).to_fs(:rounded, precision: 0) || "")
+                      m.cpu = (cw.cpu(name: rds_guid(instance.guid)).to_fs(:rounded, precision: 0) || "")
+                    end
+                    if service_offering.name == "aws-s3-bucket"
+                      m.storage_used = to_gb(cw.s3_storage_used(name: s3_guid(options[:env], instance.guid)) || "")
+                    end
+                    values << m
+                  end
+                end.map(&:value)
+              end
+
+              values << JCF::CF::Metric.new if values.empty?
+              out.puts formatter.format(values)
+              err.puts "Done."
+            end
+          end
+
+          private
+
+          def rds_guid(guid)
+            "rdsbroker-#{guid}"
+          end
+
+          def s3_guid(deploy_env, guid)
+            "paas-s3-broker-#{deploy_env}-#{guid}"
+          end
+
+          def validate_options(options)
+            raise JCF::CLI::InvalidOptionError, "No organization given" unless options[:org]
+          end
+
+          def organizations
+            @organizations ||= JCF::CF::Organization.all
+          end
+
+          def spaces
+            @spaces ||= JCF::CF::Space.all
+          end
+
+          def service_instances
+            @service_instances ||= JCF::CF::ServiceInstance.all
+          end
+
+          def service_plans
+            @service_plans ||= JCF::CF::ServicePlan.all
+          end
+
+          def service_offerings
+            @service_offerings ||= JCF::CF::ServiceOffering.all
+          end
+
+          def service_brokers
+            JCF::CF::ServiceBroker.all
+          end
+
+          def to_gb(bytes)
+            Filesize.from("#{bytes} b").to("GB").to_fs(:rounded, precision: 2)
+          rescue ArgumentError
+            0
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jcf/cli/commands/cf/organizations.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "shellwords"
+require_relative "../../errors"
+
+module JCF
+  module CLI
+    module Commands
+      module CF
+        class Organizations < Command
+          argument :name, required: false, desc: "Organization name"
+
+          def call(name: nil, **)
+            if name
+              out.puts formatter.format(JCF::CF::Organization.find_by(name: name))
+            else
+              out.puts formatter.format(JCF::CF::Organization.all)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jcf/cli/commands/cf/quota.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "shellwords"
+require_relative "../../errors"
+
+module JCF
+  module CLI
+    module Commands
+      module CF
+        class Quota < Command
+          argument :name, required: false, desc: "Quota name"
+
+          option :org, aliases: ["-o", "--org", "--organization"], type: :string, desc: "Filter to an organization"
+
+          def call(name: nil, **options)
+            if name
+              out.puts formatter.format(JCF::CF::Quota.find_by(name: name))
+            else
+              out.puts formatter.format(JCF::CF::Quota.all(org: options[:org]))
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jcf/cli/commands/cf/service_brokers.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "shellwords"
+require_relative "../../errors"
+
+module JCF
+  module CLI
+    module Commands
+      module CF
+        class ServiceBrokers < Command
+          argument :name, required: false, desc: "Service Broker name"
+
+          option :space, aliases: ["-s", "--space"], type: :string, desc: "Filter to a space"
+
+          def call(name: nil, **options)
+            if name
+              out.puts formatter.format(JCF::CF::ServiceBroker.find_by(name: name))
+            else
+              out.puts formatter.format(
+                JCF::CF::ServiceBroker.all(
+                  space_guids: options[:space]
+                )
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end