freshli-commons 0.6.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: cc5d50a4b6a1a5df06c1d51cfcc180d8236fd15145b2a205f1d3d7209e78bdd6
+  data.tar.gz: d2ad6c97040b1fddc3afb42d8d403b465a55a1d5c7c745f99570c5c8fa463d58
+SHA512:
+  metadata.gz: 99e6d91119d93d7468377e2ac87fe6e88bff94471dd61c67617222879167b97af58bc22446eba1771c6e320c5414ab219b37a50910024b7cc11c0410f449a41e
+  data.tar.gz: 56e37d6bc7ae6c825681fa1b884611f2a04faa86846a9e519610e322e27e4c2103aa87880d08e355fb80d9f840ffe30d5e1276d9cc3c2a3e74390b24b4931f80

data/.editorconfig

@@ -0,0 +1,46 @@
+# editorconfig.org
+
+# Used the .NET Runtime as the base configuration.
+#
+# https://github.com/dotnet/runtime/blob/main/.editorconfig
+
+# top-most EditorConfig file
+root = true
+
+# Default settings:
+# A newline ending every file
+# Use 4 spaces as indentation
+[*]
+insert_final_newline = true
+indent_style = space
+indent_size = 2
+trim_trailing_whitespace = true
+tab_width = 8
+
+[*.json]
+insert_final_newline = unset
+
+# Shell scripts
+[*.sh]
+end_of_line = lf
+[*.{cmd,bat}]
+end_of_line = crlf
+
+# Ruby files
+[Gemfile.lock]
+indent_size = unset
+
+[LICENSE]
+indent_size = unset
+max_line_length = unset
+
+[CONTRIBUTING.md]
+indent_size = unset
+max_line_length = unset
+
+[README.md]
+indent_size = unset
+max_line_length = unset
+
+[lib/corgibytes/freshli/commons/step_definitions/grpc/**/*.rb]
+generated_code = true

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,10 @@
+AllCops:
+  NewCops: enable
+  SuggestExtensions: false
+  TargetRubyVersion: 3.0
+  Exclude:
+    - 'lib/corgibytes/freshli/commons/step_definitions/grpc/**/*'
+    - 'vendor/bundle/**/*'
+
+Style/ConditionalAssignment:
+  Enabled: false

data/.semver

@@ -0,0 +1,6 @@
+---
+:major: 0
+:minor: 6
+:patch: 0
+:special: ''
+:metadata: ''

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Corgibytes, LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,31 @@
+# Corgibytes::Freshli::Commons
+
+TODO: Delete this and the text below, and describe your gem
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/corgibytes/freshli/commons`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+## Installation
+
+TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_PRIOR_TO_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add UPDATE_WITH_YOUR_GEM_NAME_PRIOR_TO_RELEASE_TO_RUBYGEMS_ORG
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install UPDATE_WITH_YOUR_GEM_NAME_PRIOR_TO_RELEASE_TO_RUBYGEMS_ORG
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/corgibytes/freshli-commons.

data/Rakefile

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+require 'fileutils'
+
+# TODO: Copy the `freshli_agent.proto` from the `corgibytes/freshli` repository
+# instead of having it live in this repository. Similar to what's being done
+# with the health status proto file below.
+
+# based on https://stackoverflow.com/a/29743469/243215
+def download(url, target_path)
+  # rubocop:disable Security/Open
+  require 'open-uri'
+  download = URI.open(url)
+  # rubocop:enable Security/Open
+  IO.copy_stream(download, target_path)
+end
+
+# Generate gRPC files from the freshli_agent.proto file
+GENERATED_GRPC_FILES = [
+  'lib/corgibytes/freshli/commons/step_definitions/grpc/freshli_agent_pb.rb',
+  'lib/corgibytes/freshli/commons/step_definitions/grpc/freshli_agent_services_pb.rb',
+  'lib/corgibytes/freshli/commons/step_definitions/grpc/health_services_pb.rb',
+  'lib/corgibytes/freshli/commons/step_definitions/grpc/health_pb.rb'
+].freeze
+# rubocop:disable Metrics/BlockLength
+namespace :grpc do
+  task :generate do
+    Rake::Task['grpc:generate:force'].invoke unless GENERATED_GRPC_FILES.all? { |file| File.exist?(file) }
+  end
+
+  namespace :generate do
+    desc 'Generate gRPC files even if they already exist'
+    task :force do
+      system(
+        'bundle exec grpc_tools_ruby_protoc -I ' \
+        './protos/corgibytes/freshli/agent/grpc ' \
+        '--ruby_out=./lib/corgibytes/freshli/commons/step_definitions/grpc ' \
+        '--grpc_out=./lib/corgibytes/freshli/commons/step_definitions/grpc ' \
+        './protos/corgibytes/freshli/agent/grpc/freshli_agent.proto'
+      )
+
+      FileUtils.mkdir_p('tmp')
+
+      download(
+        'https://raw.githubusercontent.com/grpc/grpc/e35cf362a49b4de753cbe69f3e836d2e40408ca2' \
+        '/src/proto/grpc/health/v1/health.proto',
+        File.expand_path(File.join(File.dirname(__FILE__), 'tmp', 'health.proto'))
+      )
+      system(
+        'bundle exec grpc_tools_ruby_protoc -I tmp ' \
+        '--ruby_out=lib/corgibytes/freshli/commons/step_definitions/grpc ' \
+        '--grpc_out=lib/corgibytes/freshli/commons/step_definitions/grpc ' \
+        'tmp/health.proto'
+      )
+    end
+  end
+end
+# rubocop:enable Metrics/BlockLength
+
+desc 'Generate gRPC files'
+task grpc: %i[grpc:generate]
+
+# Ensure that the grpc files are generated before the tests run
+RSpec::Core::RakeTask.new(spec: 'grpc')
+
+require 'rubocop/rake_task'
+
+RuboCop::RakeTask.new
+
+# Ensure that the grpc files are generated before the build runs
+Rake::Task['build'].enhance(['grpc'])
+
+task default: %i[grpc spec rubocop]

data/exe/shutdown-grpc

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# This script helps with cleaning up gRPC servers that might be left running when some of the tests fail.
+# You can pass it multiple port arguments separated by spaces, and it will attempt to connect to and close each one.
+
+$LOAD_PATH.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..', 'features', 'support')))
+$LOAD_PATH.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..', 'features', 'step_definitions', 'grpc')))
+
+require 'grpc_client'
+
+ARGV.each do |port|
+  GrpcClient.new(port).shutdown!
+end

data/lib/corgibytes/freshli/commons/execute.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+module Corgibytes
+  module Freshli
+    module Commons
+      # Contains utility methods for executing commands and working with their output.
+      module Execute
+        def enable_dotnet_command_colors
+          ENV['DOTNET_SYSTEM_CONSOLE_ALLOW_ANSI_COLOR_REDIRECTION'] = 'true'
+        end
+
+        def stream_eof?(status)
+          status.nil?
+        end
+
+        def stream_open_but_empty?(status)
+          status.empty? || status == :wait_readable
+        end
+
+        def safe_to_read?(status)
+          !stream_eof?(status) && !stream_open_but_empty?(status)
+        end
+
+        def write_buffered_output_to_correct_stream(buffer, stream, stdout, stderr)
+          if stream == stdout
+            $stdout.print(buffer)
+          elsif stream == stderr
+            $stderr.print(buffer)
+          end
+        end
+
+        BUFFER_LEN = 128
+
+        def fill_buffer_from_stream(stream, buffer)
+          # loop through reading data until there is an EOF (value is nil)
+          # or there is no more data to read (value is empty)
+          result = nil
+          loop do
+            local_buffer = ''.dup
+            result = stream.read_nonblock(BUFFER_LEN, local_buffer, exception: false)
+            buffer << local_buffer
+
+            break unless safe_to_read?(result) && buffer.length < BUFFER_LEN
+          end
+          result
+        end
+
+        def read_streams(for_reading, readable, stdout, stderr)
+          # In the case that both streams are readable (and thus have content)
+          # read from each of them. In this case, we cannot guarantee any order
+          # because we recieve the items at essentially the same time.
+          # We can still ensure that we don't mix data incorrectly.
+          readable.each do |stream|
+            buffer = ''.dup
+            result = fill_buffer_from_stream(stream, buffer)
+
+            for_reading -= [stream] if stream_eof?(result)
+
+            write_buffered_output_to_correct_stream(buffer, stream, stdout, stderr)
+          end
+          for_reading
+        end
+
+        def skip_or_read_streams(for_reading, readable, stdout, stderr)
+          # readable is nil in the case of a timeout - loop back again
+          if readable.nil?
+            Thread.pass
+          else
+            for_reading = read_streams(for_reading, readable, stdout, stderr)
+          end
+          for_reading
+        end
+
+        WAIT_TIMEOUT = 1
+        def execute(command)
+          exit_status = nil
+          Open3.popen3(command) do |_in, stdout, stderr, wait_thread|
+            for_reading = [stdout, stderr]
+            until for_reading.empty?
+              # IO.select blocks until one of the streams is has something to read
+              # or the wait timeout is reached
+              readable, _writable, _errors = IO.select(for_reading, [], [], WAIT_TIMEOUT)
+              for_reading = skip_or_read_streams(for_reading, readable, stdout, stderr)
+            end
+
+            exit_status = wait_thread.value
+          end
+          exit_status
+        end
+
+        def null_output_target
+          Gem.win_platform? ? 'NUL:' : '/dev/null'
+        end
+      end
+    end
+  end
+end

data/lib/corgibytes/freshli/commons/grpc_client.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require 'timeout'
+
+require 'rspec/expectations'
+
+$LOAD_PATH.unshift(File.expand_path(File.join(File.dirname(__FILE__), 'step_definitions', 'grpc')))
+
+require 'freshli_agent_services_pb'
+require 'health_services_pb'
+
+module Corgibytes
+  module Freshli
+    module Commons
+      # Test driver client for communicating with the gRPC API.
+      class GrpcClient
+        include RSpec::Matchers
+
+        def initialize(port)
+          @port = port
+        end
+
+        def shutdown!
+          client = grpc_agent_client_on(@port)
+          response = client.shutdown(::Google::Protobuf::Empty.new)
+          expect(response).to be_a(::Google::Protobuf::Empty)
+        end
+
+        def detect_manifests(project_path)
+          client = grpc_agent_client_on(@captured_port)
+          response = client.detect_manifests(::Com::Corgibytes::Freshli::Agent::ProjectLocation.new(path: project_path))
+
+          result = []
+          response.each do |location|
+            result << location.path
+          end
+          result
+        end
+
+        # rubocop:disable Naming/AccessorMethodName
+        def get_validating_packages
+          client = grpc_agent_client_on(@port)
+          response = client.get_validating_packages(::Google::Protobuf::Empty.new)
+
+          result = []
+          response.each do |package|
+            result << package.purl
+          end
+          result
+        end
+
+        def get_validating_repositories
+          client = grpc_agent_client_on(@port)
+          response = client.get_validating_repositories(::Google::Protobuf::Empty.new)
+
+          result = []
+          response.each do |repository|
+            result << repository.url
+          end
+          result
+        end
+        # rubocop:enable Naming/AccessorMethodName
+
+        def process_manifest(manifest_path, moment_in_time)
+          client = grpc_agent_client_on(@port)
+          response = client.process_manifest(
+            ::Com::Corgibytes::Freshli::Agent::ProcessingRequest.new(
+              manifest: ::Com::Corgibytes::Freshli::Agent::ManifestLocation.new(path: manifest_path),
+              moment: ::Google::Protobuf::Timestamp.from_time(moment_in_time.to_time)
+            )
+          )
+          response.path
+        end
+
+        def retrieve_release_history(package_url)
+          client = grpc_agent_client_on(@port)
+          response = client.retrieve_release_history(::Com::Corgibytes::Freshli::Agent::Package.new(purl: package_url))
+          result = []
+          response.each do |release|
+            result << {
+              version: release.version,
+              released_at: release.released_at.to_time.to_datetime.new_offset('0:00')
+            }
+          end
+          result
+        end
+
+        def health_check
+          client = Grpc::Health::V1::Health::Stub.new("localhost:#{@port}", :this_channel_is_insecure)
+          response = client.check(
+            Grpc::Health::V1::HealthCheckRequest.new(
+              service: Com::Corgibytes::Freshli::Agent::Agent::Service.service_name
+            )
+          )
+          response.status
+        end
+
+        # rubocop:disable Naming/PredicateName
+        def is_running!
+          expect(health_check).to eq(:SERVING)
+        end
+        # rubocop:enable Naming/PredicateName
+
+        # rubocop:disable Metrics/MethodLength
+        def wait_until_running!
+          Timeout.timeout(5) do
+            loop do
+              status = nil
+              begin
+                status = health_check
+              rescue GRPC::Unavailable
+                status = nil
+              end
+
+              break if status == :SERVING
+
+              sleep 0.1
+            end
+          end
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        private
+
+        def grpc_agent_client_on(_port)
+          Com::Corgibytes::Freshli::Agent::Agent::Stub.new("localhost:#{@port}", :this_channel_is_insecure)
+        end
+      end
+    end
+  end
+end

data/lib/corgibytes/freshli/commons/platform.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Corgibytes
+  module Freshli
+    module Commons
+      # Contains helper methods for coping with platform specific differences
+      module Platform
+        def self.null_output_target
+          Gem.win_platform? ? 'NUL:' : '/dev/null'
+        end
+
+        def self.normalize_file_separators(value)
+          separator = File::ALT_SEPARATOR || File::SEPARATOR
+          value.gsub('/', separator)
+        end
+      end
+    end
+  end
+end

data/lib/corgibytes/freshli/commons/ports.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Corgibytes
+  module Freshli
+    module Commons
+      # Contains utility methods for working with IP ports, specifically determining which ones are available for use.
+      module Ports
+        # rubocop:disable Metrics/MethodLength
+        def self.available?(port)
+          max_attempts = 1000
+          attempts = 0
+          begin
+            attempts += 1
+            yield(attempts) if block_given?
+            attempt_connection(port)
+            true
+          rescue Errno::EADDRINUSE
+            if attempts < max_attempts
+              sleep 0.1
+              retry
+            end
+            false
+          end
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        def self.attempt_connection(port)
+          # based on https://stackoverflow.com/a/34375147/243215
+          require 'socket'
+          socket = Socket.new(Socket::Constants::AF_INET, Socket::Constants::SOCK_STREAM, 0)
+          socket.bind(Socket.pack_sockaddr_in(port, '0.0.0.0'))
+          socket.close
+        end
+      end
+    end
+  end
+end

data/lib/corgibytes/freshli/commons/step_definitions/command.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'corgibytes/freshli/commons/platform'
+Platform = Corgibytes::Freshli::Commons::Platform
+
+# this block is based on https://github.com/cucumber/aruba/blob/v2.1.0/lib/aruba/cucumber/command.rb#L404..L414
+Then(/^it should (pass|fail) with exact output containing file paths:$/) do |pass_fail, expected|
+  last_command_started.stop
+
+  if pass_fail == 'pass'
+    expect(last_command_stopped).to be_successfully_executed
+  else
+    expect(last_command_stopped).not_to be_successfully_executed
+  end
+
+  expect(last_command_stopped).to have_output an_output_string_being_eq(Platform.normalize_file_separators(expected))
+end

data/lib/corgibytes/freshli/commons/step_definitions/cyclonedx.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'corgibytes/freshli/commons/platform'
+Platform = Corgibytes::Freshli::Commons::Platform
+
+Then('the CycloneDX file {string} should be valid') do |bom_path|
+  full_bom_path = Platform.normalize_file_separators("#{Aruba.config.working_directory}/#{bom_path}")
+  unless system("cyclonedx validate --fail-on-errors --input-file #{full_bom_path}",
+                out: Platform.null_output_target, err: Platform.null_output_target)
+    raise "CycloneDX file is not valid: #{bom_path}"
+  end
+end
+
+Then('the CycloneDX file {string} should contain {string}') do |bom_path, package_url|
+  full_bom_path = Platform.normalize_file_separators("#{Aruba.config.working_directory}/#{bom_path}")
+  bom_file_lines = File.readlines(full_bom_path)
+  was_package_url_found = false
+  bom_file_lines.each do |line|
+    if line.include?(package_url)
+      was_package_url_found = true
+      break
+    end
+  end
+  raise "Unable to find #{package_url} in #{bom_path}" unless was_package_url_found
+end

data/lib/corgibytes/freshli/commons/step_definitions/git.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+require 'corgibytes/freshli/commons/platform'
+Platform = Corgibytes::Freshli::Commons::Platform
+
+Given('I clone the git repository {string} with the sha {string}') do |repository_url, sha|
+  repositories_dir = "#{Aruba.config.working_directory}/tmp/repositories"
+  cloned_dir = "#{repositories_dir}/#{repository_url.split('/').last}"
+
+  FileUtils.mkdir_p(repositories_dir)
+
+  unless Dir.exist?(cloned_dir)
+    $stdout.print "Cloning #{repository_url} ..."
+    unless system(
+      "git clone #{repository_url}",
+      chdir: repositories_dir,
+      out: Platform.null_output_target,
+      err: Platform.null_output_target
+    )
+      raise "Failed to clone #{repository_url}"
+    end
+
+    puts 'done.'
+  end
+  unless system(
+    "git checkout #{sha}",
+    chdir: cloned_dir,
+    out: Platform.null_output_target,
+    err: Platform.null_output_target
+  )
+    raise "Failed to checkout #{sha}"
+  end
+end
+
+Then('running git status should not report any modifications for {string}') do |git_repository_path|
+  git_repository_path_in_working_directory = "#{Aruba.config.working_directory}/#{git_repository_path}"
+  system(
+    'git update-index --refresh',
+    chdir: git_repository_path_in_working_directory,
+    out: Platform.null_output_target,
+    err: Platform.null_output_target
+  )
+  unless system(
+    'git diff-index --quiet HEAD --',
+    chdir: git_repository_path_in_working_directory,
+    out: Platform.null_output_target,
+    err: Platform.null_output_target
+  )
+    raise "The working directory is not clean: #{git_repository_path}"
+  end
+end

data/lib/corgibytes/freshli/commons/step_definitions/grpc/freshli_agent_pb.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: freshli_agent.proto
+
+require 'google/protobuf'
+
+require 'google/protobuf/empty_pb'
+require 'google/protobuf/timestamp_pb'
+
+
+descriptor_data = "\n\x13\x66reshli_agent.proto\x12\x1c\x63om.corgibytes.freshli.agent\x1a\x1bgoogle/protobuf/empty.proto\x1a\x1fgoogle/protobuf/timestamp.proto\"\x1f\n\x0fProjectLocation\x12\x0c\n\x04path\x18\x01 \x01(\t\" \n\x10ManifestLocation\x12\x0c\n\x04path\x18\x01 \x01(\t\"\x81\x01\n\x11ProcessingRequest\x12@\n\x08manifest\x18\x01 \x01(\x0b\x32..com.corgibytes.freshli.agent.ManifestLocation\x12*\n\x06moment\x18\x02 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\"\x1b\n\x0b\x42omLocation\x12\x0c\n\x04path\x18\x01 \x01(\t\"\x17\n\x07Package\x12\x0c\n\x04purl\x18\x01 \x01(\t\"R\n\x0ePackageRelease\x12\x0f\n\x07version\x18\x01 \x01(\t\x12/\n\x0breleased_at\x18\x02 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\"!\n\x12RepositoryLocation\x12\x0b\n\x03url\x18\x01 \x01(\t2\xda\x04\n\x05\x41gent\x12r\n\x0f\x44\x65tectManifests\x12-.com.corgibytes.freshli.agent.ProjectLocation\x1a..com.corgibytes.freshli.agent.ManifestLocation0\x01\x12m\n\x0fProcessManifest\x12/.com.corgibytes.freshli.agent.ProcessingRequest\x1a).com.corgibytes.freshli.agent.BomLocation\x12o\n\x16RetrieveReleaseHistory\x12%.com.corgibytes.freshli.agent.Package\x1a,.com.corgibytes.freshli.agent.PackageRelease0\x01\x12X\n\x15GetValidatingPackages\x12\x16.google.protobuf.Empty\x1a%.com.corgibytes.freshli.agent.Package0\x01\x12g\n\x19GetValidatingRepositories\x12\x16.google.protobuf.Empty\x1a\x30.com.corgibytes.freshli.agent.RepositoryLocation0\x01\x12:\n\x08Shutdown\x12\x16.google.protobuf.Empty\x1a\x16.google.protobuf.Emptyb\x06proto3"
+
+pool = Google::Protobuf::DescriptorPool.generated_pool
+
+begin
+  pool.add_serialized_file(descriptor_data)
+rescue TypeError => e
+  # Compatibility code: will be removed in the next major version.
+  require 'google/protobuf/descriptor_pb'
+  parsed = Google::Protobuf::FileDescriptorProto.decode(descriptor_data)
+  parsed.clear_dependency
+  serialized = parsed.class.encode(parsed)
+  file = pool.add_serialized_file(serialized)
+  warn "Warning: Protobuf detected an import path issue while loading generated file #{__FILE__}"
+  imports = [
+    ["google.protobuf.Timestamp", "google/protobuf/timestamp.proto"],
+  ]
+  imports.each do |type_name, expected_filename|
+    import_file = pool.lookup(type_name).file_descriptor
+    if import_file.name != expected_filename
+      warn "- #{file.name} imports #{expected_filename}, but that import was loaded as #{import_file.name}"
+    end
+  end
+  warn "Each proto file must use a consistent fully-qualified name."
+  warn "This will become an error in the next major version."
+end
+
+module Com
+  module Corgibytes
+    module Freshli
+      module Agent
+        ProjectLocation = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("com.corgibytes.freshli.agent.ProjectLocation").msgclass
+        ManifestLocation = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("com.corgibytes.freshli.agent.ManifestLocation").msgclass
+        ProcessingRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("com.corgibytes.freshli.agent.ProcessingRequest").msgclass
+        BomLocation = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("com.corgibytes.freshli.agent.BomLocation").msgclass
+        Package = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("com.corgibytes.freshli.agent.Package").msgclass
+        PackageRelease = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("com.corgibytes.freshli.agent.PackageRelease").msgclass
+        RepositoryLocation = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("com.corgibytes.freshli.agent.RepositoryLocation").msgclass
+      end
+    end
+  end
+end

data/lib/corgibytes/freshli/commons/step_definitions/grpc/freshli_agent_services_pb.rb

@@ -0,0 +1,33 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# Source: freshli_agent.proto for package 'com.corgibytes.freshli.agent'
+
+require 'grpc'
+require 'freshli_agent_pb'
+
+module Com
+  module Corgibytes
+    module Freshli
+      module Agent
+        module Agent
+          class Service
+
+            include ::GRPC::GenericService
+
+            self.marshal_class_method = :encode
+            self.unmarshal_class_method = :decode
+            self.service_name = 'com.corgibytes.freshli.agent.Agent'
+
+            rpc :DetectManifests, ::Com::Corgibytes::Freshli::Agent::ProjectLocation, stream(::Com::Corgibytes::Freshli::Agent::ManifestLocation)
+            rpc :ProcessManifest, ::Com::Corgibytes::Freshli::Agent::ProcessingRequest, ::Com::Corgibytes::Freshli::Agent::BomLocation
+            rpc :RetrieveReleaseHistory, ::Com::Corgibytes::Freshli::Agent::Package, stream(::Com::Corgibytes::Freshli::Agent::PackageRelease)
+            rpc :GetValidatingPackages, ::Google::Protobuf::Empty, stream(::Com::Corgibytes::Freshli::Agent::Package)
+            rpc :GetValidatingRepositories, ::Google::Protobuf::Empty, stream(::Com::Corgibytes::Freshli::Agent::RepositoryLocation)
+            rpc :Shutdown, ::Google::Protobuf::Empty, ::Google::Protobuf::Empty
+          end
+
+          Stub = Service.rpc_stub_class
+        end
+      end
+    end
+  end
+end

data/lib/corgibytes/freshli/commons/step_definitions/grpc/health_pb.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: health.proto
+
+require 'google/protobuf'
+
+
+descriptor_data = "\n\x0chealth.proto\x12\x0egrpc.health.v1\"%\n\x12HealthCheckRequest\x12\x0f\n\x07service\x18\x01 \x01(\t\"\xa9\x01\n\x13HealthCheckResponse\x12\x41\n\x06status\x18\x01 \x01(\x0e\x32\x31.grpc.health.v1.HealthCheckResponse.ServingStatus\"O\n\rServingStatus\x12\x0b\n\x07UNKNOWN\x10\x00\x12\x0b\n\x07SERVING\x10\x01\x12\x0f\n\x0bNOT_SERVING\x10\x02\x12\x13\n\x0fSERVICE_UNKNOWN\x10\x03\x32\xae\x01\n\x06Health\x12P\n\x05\x43heck\x12\".grpc.health.v1.HealthCheckRequest\x1a#.grpc.health.v1.HealthCheckResponse\x12R\n\x05Watch\x12\".grpc.health.v1.HealthCheckRequest\x1a#.grpc.health.v1.HealthCheckResponse0\x01\x42\x61\n\x11io.grpc.health.v1B\x0bHealthProtoP\x01Z,google.golang.org/grpc/health/grpc_health_v1\xaa\x02\x0eGrpc.Health.V1b\x06proto3"
+
+pool = Google::Protobuf::DescriptorPool.generated_pool
+
+begin
+  pool.add_serialized_file(descriptor_data)
+rescue TypeError => e
+  # Compatibility code: will be removed in the next major version.
+  require 'google/protobuf/descriptor_pb'
+  parsed = Google::Protobuf::FileDescriptorProto.decode(descriptor_data)
+  parsed.clear_dependency
+  serialized = parsed.class.encode(parsed)
+  file = pool.add_serialized_file(serialized)
+  warn "Warning: Protobuf detected an import path issue while loading generated file #{__FILE__}"
+  imports = [
+  ]
+  imports.each do |type_name, expected_filename|
+    import_file = pool.lookup(type_name).file_descriptor
+    if import_file.name != expected_filename
+      warn "- #{file.name} imports #{expected_filename}, but that import was loaded as #{import_file.name}"
+    end
+  end
+  warn "Each proto file must use a consistent fully-qualified name."
+  warn "This will become an error in the next major version."
+end
+
+module Grpc
+  module Health
+    module V1
+      HealthCheckRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("grpc.health.v1.HealthCheckRequest").msgclass
+      HealthCheckResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("grpc.health.v1.HealthCheckResponse").msgclass
+      HealthCheckResponse::ServingStatus = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("grpc.health.v1.HealthCheckResponse.ServingStatus").enummodule
+    end
+  end
+end

data/lib/corgibytes/freshli/commons/step_definitions/grpc/health_services_pb.rb

@@ -0,0 +1,62 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# Source: health.proto for package 'grpc.health.v1'
+# Original file comments:
+# Copyright 2015 The gRPC Authors
+#
+# 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.
+#
+# The canonical version of this proto can be found at
+# https://github.com/grpc/grpc-proto/blob/master/grpc/health/v1/health.proto
+#
+
+require 'grpc'
+require 'health_pb'
+
+module Grpc
+  module Health
+    module V1
+      module Health
+        class Service
+
+          include ::GRPC::GenericService
+
+          self.marshal_class_method = :encode
+          self.unmarshal_class_method = :decode
+          self.service_name = 'grpc.health.v1.Health'
+
+          # If the requested service is unknown, the call will fail with status
+          # NOT_FOUND.
+          rpc :Check, ::Grpc::Health::V1::HealthCheckRequest, ::Grpc::Health::V1::HealthCheckResponse
+          # Performs a watch for the serving status of the requested service.
+          # The server will immediately send back a message indicating the current
+          # serving status.  It will then subsequently send a new message whenever
+          # the service's serving status changes.
+          #
+          # If the requested service is unknown when the call is received, the
+          # server will send a message setting the serving status to
+          # SERVICE_UNKNOWN but will *not* terminate the call.  If at some
+          # future point, the serving status of the service becomes known, the
+          # server will send a new message with the service's serving status.
+          #
+          # If the call terminates with status UNIMPLEMENTED, then clients
+          # should assume this method is not supported and should not retry the
+          # call.  If the call terminates with any other status (including OK),
+          # clients should retry the call with appropriate exponential backoff.
+          rpc :Watch, ::Grpc::Health::V1::HealthCheckRequest, stream(::Grpc::Health::V1::HealthCheckResponse)
+        end
+
+        Stub = Service.rpc_stub_class
+      end
+    end
+  end
+end

data/lib/corgibytes/freshli/commons/step_definitions/grpc.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require 'time'
+require 'google/protobuf/well_known_types'
+
+require 'corgibytes/freshli/commons/test_services'
+TestServices = Corgibytes::Freshli::Commons::TestServices
+require 'corgibytes/freshli/commons/grpc_client'
+GrpcClient = Corgibytes::Freshli::Commons::GrpcClient
+require 'corgibytes/freshli/commons/ports'
+Ports = Corgibytes::Freshli::Commons::Ports
+
+Then('the freshli_agent.proto gRPC service is running on port {int}') do |port|
+  GrpcClient.new(port).is_running!
+end
+
+When('I wait for the freshli_agent.proto gRPC service to be running on port {int}') do |port|
+  GrpcClient.new(port).wait_until_running!
+end
+
+When('the gRPC service on port {int} is sent the shutdown command') do |port|
+  GrpcClient.new(port).shutdown!
+end
+
+Then('there are no services running on port {int}') do |port|
+  expect(Ports.available?(port) { |attempts| log(attempts) }).to be_truthy
+end
+
+test_services = TestServices.new
+
+Given('a test service is started on port {int}') do |port|
+  test_services.start_on(port)
+end
+
+When('the test service running on port {int} is stopped') do |port|
+  test_services.stop_on(port)
+end
+
+When('I call DetectManifests with the full path to {string} on port {int}') do |project_path, port|
+  expanded_path = Platform.normalize_file_separators(
+    File.expand_path(File.join(aruba.config.home_directory, project_path))
+  )
+
+  @detect_manifests_paths = GrpcClient.new(port).detect_manifests(expanded_path)
+end
+
+def expanded_paths_from(doc_string, project_path)
+  result = []
+  doc_string.each_line do |file_path|
+    result << Platform.normalize_file_separators(
+      File.expand_path(File.join(aruba.config.home_directory, project_path, file_path.strip))
+    )
+  end
+  result
+end
+
+Then('the DetectManifests response contains the following file paths expanded beneath {string}:') do
+  |project_path, doc_string|
+
+  expected_paths = expanded_paths_from(doc_string, project_path)
+  expect(@detect_manifests_paths).to eq(expected_paths)
+end
+
+When('I call GetValidatingPackages on port {int}') do |port|
+  @get_validating_packages_results = GrpcClient.new(port).get_validating_packages
+end
+
+Then('the GetValidatingPackages response should contain:') do |doc_string|
+  expected_packages = []
+  doc_string.each_line do |package_url|
+    expected_packages << package_url.strip
+  end
+
+  expect(@get_validating_packages_results).to eq(expected_packages)
+end
+
+When('I call GetValidatingRepositories on port {int}') do |port|
+  @get_validating_repositories_results = GrpcClient.new(port).get_validating_repositories
+end
+
+Then('GetValidatingRepositories response should contain:') do |doc_string|
+  expected_repositories = []
+  doc_string.each_line do |repository|
+    expected_repositories << repository.strip
+  end
+
+  expect(@get_validating_repositories_results).to eq(expected_repositories)
+end
+
+When('I call ProcessManifest with the expanded path {string} and the moment {string} on port {int}') do
+  |manifest_path, moment_in_time, port|
+
+  expanded_path = Platform.normalize_file_separators(
+    File.expand_path(File.join(aruba.config.home_directory, manifest_path))
+  )
+  @process_manifest_result = GrpcClient.new(port).process_manifest(
+    expanded_path, DateTime.parse(moment_in_time)
+  )
+end
+
+Then('the ProcessManifest response contains the following file paths expanded beneath {string}:') do
+  |project_path, doc_string|
+
+  expected_paths = expanded_paths_from(doc_string, project_path)
+
+  expect([@process_manifest_result]).to eq(expected_paths)
+end
+
+When('I call RetrieveReleaseHistory with {string} on port {int}') do |package_url, port|
+  @retrieve_release_history_results = GrpcClient.new(port).retrieve_release_history(package_url)
+end
+
+Then('RetrieveReleaseHistory response should contain the following versions and release dates:') do |doc_string|
+  expected_package_releases = []
+  doc_string.each_line do |line|
+    splits = line.strip.split("\t")
+    expected_package_releases << { version: splits[0], released_at: DateTime.parse(splits[1]).new_offset('0:00') }
+  end
+
+  filtered_results = @retrieve_release_history_results.take(expected_package_releases.length)
+
+  expect(filtered_results).to eq(expected_package_releases)
+end
+
+Then('RetrieveReleaseHistory response should be empty') do
+  expect(@retrieve_release_history_results).to be_empty
+end

data/lib/corgibytes/freshli/commons/step_definitions.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative 'step_definitions/command'
+require_relative 'step_definitions/cyclonedx'
+require_relative 'step_definitions/git'
+require_relative 'step_definitions/grpc'

data/lib/corgibytes/freshli/commons/test_services.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'rspec/expectations'
+
+module Corgibytes
+  module Freshli
+    module Commons
+      # Controls running test services on specific ports. Used to force a specific port to be in use.
+      class TestServices
+        include RSpec::Matchers
+
+        def initialize
+          @test_services = {}
+        end
+
+        def start_on(port)
+          expect(@test_services).not_to have_key(port)
+
+          socket4 = Socket.new(Socket::Constants::AF_INET, Socket::Constants::SOCK_STREAM, 0)
+          socket4.bind(Socket.pack_sockaddr_in(port, '0.0.0.0'))
+
+          # bind to a socket using both ipv4 and ipv6
+          socket6 = Socket.new(Socket::Constants::AF_INET6, Socket::Constants::SOCK_STREAM, 0)
+          socket6.bind(Socket.pack_sockaddr_in(port, '::'))
+
+          @test_services[port] = { v4: socket4, v6: socket6 }
+        end
+
+        def stop_on(port)
+          expect(@test_services).to have_key(port)
+
+          socket4 = @test_services[port][:v4]
+          socket4.close
+          socket6 = @test_services[port][:v6]
+          socket6.close
+        end
+      end
+    end
+  end
+end

data/lib/corgibytes/freshli/commons.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Corgibytes
+  module Freshli
+    module Commons
+      class Error < StandardError; end
+      # Your code goes here...
+    end
+  end
+end

data/protos/corgibytes/freshli/agent/grpc/freshli_agent.proto

@@ -0,0 +1,45 @@
+syntax = "proto3";
+
+package com.corgibytes.freshli.agent;
+
+import "google/protobuf/empty.proto";
+import "google/protobuf/timestamp.proto";
+
+service Agent {
+  rpc DetectManifests(ProjectLocation) returns (stream ManifestLocation);
+  rpc ProcessManifest(ProcessingRequest) returns (BomLocation);
+  rpc RetrieveReleaseHistory(Package) returns (stream PackageRelease);
+  rpc GetValidatingPackages(google.protobuf.Empty) returns (stream Package);
+  rpc GetValidatingRepositories(google.protobuf.Empty) returns (stream RepositoryLocation);
+  rpc Shutdown(google.protobuf.Empty) returns (google.protobuf.Empty);
+}
+
+message ProjectLocation {
+  string path = 1;
+}
+
+message ManifestLocation {
+  string path = 1;
+}
+
+message ProcessingRequest {
+  ManifestLocation manifest = 1;
+  google.protobuf.Timestamp moment = 2;
+}
+
+message BomLocation {
+  string path = 1;
+}
+
+message Package {
+  string purl = 1;
+}
+
+message PackageRelease {
+  string version = 1;
+  google.protobuf.Timestamp released_at = 2;
+}
+
+message RepositoryLocation {
+  string url = 1;
+}

data/sig/corgibytes/freshli/commons.rbs

@@ -0,0 +1,8 @@
+module Corgibytes
+  module Freshli
+    module Commons
+      VERSION: String
+      # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+    end
+  end
+end

metadata

@@ -0,0 +1,128 @@
+--- !ruby/object:Gem::Specification
+name: freshli-commons
+version: !ruby/object:Gem::Version
+  version: 0.6.0
+platform: ruby
+authors:
+- M. Scott Ford
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2023-08-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aruba
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+- !ruby/object:Gem::Dependency
+  name: grpc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-expectations
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description:
+email:
+- scott@corgibytes.com
+executables:
+- shutdown-grpc
+extensions: []
+extra_rdoc_files: []
+files:
+- ".editorconfig"
+- ".rspec"
+- ".rubocop.yml"
+- ".semver"
+- LICENSE
+- README.md
+- Rakefile
+- exe/shutdown-grpc
+- lib/corgibytes/freshli/commons.rb
+- lib/corgibytes/freshli/commons/execute.rb
+- lib/corgibytes/freshli/commons/grpc_client.rb
+- lib/corgibytes/freshli/commons/platform.rb
+- lib/corgibytes/freshli/commons/ports.rb
+- lib/corgibytes/freshli/commons/step_definitions.rb
+- lib/corgibytes/freshli/commons/step_definitions/command.rb
+- lib/corgibytes/freshli/commons/step_definitions/cyclonedx.rb
+- lib/corgibytes/freshli/commons/step_definitions/git.rb
+- lib/corgibytes/freshli/commons/step_definitions/grpc.rb
+- lib/corgibytes/freshli/commons/step_definitions/grpc/.gitkeep
+- lib/corgibytes/freshli/commons/step_definitions/grpc/freshli_agent_pb.rb
+- lib/corgibytes/freshli/commons/step_definitions/grpc/freshli_agent_services_pb.rb
+- lib/corgibytes/freshli/commons/step_definitions/grpc/health_pb.rb
+- lib/corgibytes/freshli/commons/step_definitions/grpc/health_services_pb.rb
+- lib/corgibytes/freshli/commons/test_services.rb
+- protos/corgibytes/freshli/agent/grpc/freshli_agent.proto
+- sig/corgibytes/freshli/commons.rbs
+homepage: https://github.com/corgibytes/freshli-commons
+licenses: []
+metadata:
+  homepage_uri: https://github.com/corgibytes/freshli-commons
+  source_code_uri: https://github.com/corgibytes/freshli-commons
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.33
+signing_key:
+specification_version: 4
+summary: Common build and testing code that is shared amongst the Freshli repositories
+test_files: []