kscript 0.1.0

data/lib/kscript/plugins/kk_apnic_utils.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+# Copyright (c) 2025 Kk
+#
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+require 'kscript'
+
+module Kscript
+  class KkApnicUtils < Base
+    attr_reader :country_sn, :cache_file
+
+    # Initialize class instance, set country code and cache file path
+    def initialize(country_sn = 'CN', *_args, **opts)
+      super(**opts.merge(service: 'kk_apnic'))
+      @country_sn = country_sn
+      @cache_file = RUBY_PLATFORM.match?(/(linux|darwin)/) ? '/tmp/apnic.txt' : 'apnic.txt'
+    end
+
+    # Download data from APNIC or read from cache
+    def download_data
+      if File.exist?(cache_file) && File.size?(cache_file)
+        logger.kinfo("Using cached data from #{cache_file}")
+      else
+        url = 'https://ftp.apnic.net/stats/apnic/delegated-apnic-latest'
+        response = HTTP.get(url)
+
+        raise "Failed to download the APNIC data. HTTP Status: #{response.status}" unless response.status.success?
+
+        File.write(cache_file, response.body.to_s)
+        logger.kinfo("Data downloaded and saved to #{cache_file}")
+      end
+    end
+
+    # Parse data and return IPv4 address ranges (CIDR format) for specified country
+    def parse_ip_ranges
+      download_data # Ensure data is downloaded first
+
+      pattern = /apnic\|#{country_sn}\|ipv4\|(?<ip>\d+\.\d+\.\d+\.\d+)\|(?<hosts>\d+)\|\d+\|allocated/mi
+      ip_ranges = []
+
+      File.readlines(cache_file).each do |line|
+        next unless line.match(pattern)
+
+        val = line.match(pattern)
+        netmask = calculate_netmask(val[:hosts].to_i)
+        ip_ranges << "#{val[:ip]}/#{netmask}"
+      end
+
+      logger.kinfo('IP ranges', ip_ranges: ip_ranges)
+      ip_ranges
+    end
+
+    # Calculate CIDR netmask based on number of hosts
+    def calculate_netmask(hosts)
+      # Calculate minimum CIDR netmask
+      32 - Math.log2(hosts).to_i
+    end
+
+    def run
+      with_error_handling do
+        parse_ip_ranges
+      end
+    end
+
+    def self.arguments
+      '[country_code]'
+    end
+
+    def self.usage
+      "kscript apnic CN\nkscript apnic US"
+    end
+
+    def self.group
+      'network'
+    end
+
+    def self.author
+      'kk'
+    end
+
+    def self.description
+      'Get APNIC IPv4 ranges for a country.'
+    end
+  end
+end

data/lib/kscript/plugins/kk_cleaner_utils.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+# Copyright (c) 2025 Kk
+#
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+require 'kscript'
+
+module Kscript
+  class KkCleanerUtils < Base
+    DEFAULT_RETAIN_VERSIONS = 10
+
+    attr_reader :source_path, :retain_count
+
+    # Initialize the cleaner with path and retention settings
+    # @param source_path [String] path to source code directory
+    # @param retain_count [Integer] number of versions to keep
+    def initialize(source_path = '/data/sources/*/**', retain_count = DEFAULT_RETAIN_VERSIONS, *_args, **opts)
+      super(**opts.merge(service: 'kk_source_cleaner'))
+      @source_path = source_path
+      @retain_count = retain_count
+    end
+
+    def run
+      with_error_handling do
+        clean
+      end
+    end
+
+    # Clean old versions while keeping the specified number of recent versions
+    def clean
+      Dir.glob(@source_path).each do |app_path|
+        process_application(app_path)
+      end
+    end
+
+    def self.arguments
+      '[src_path]'
+    end
+
+    def self.usage
+      "kscript source_cleaner ~/projects/src\nkscript source_cleaner . --exclude=vendor"
+    end
+
+    def self.group
+      'project'
+    end
+
+    def self.author
+      'kk'
+    end
+
+    def self.description
+      'Clean old source code versions, keep N latest.'
+    end
+
+    private
+
+    # Process a single application directory
+    # @param app_path [String] path to application directory
+    def process_application(app_path)
+      versions = Dir.glob("#{app_path}/*")
+      version_count = versions.length
+      return if version_count <= @retain_count
+
+      logger.info("Processing #{app_path}", version_count: version_count, retain: @retain_count)
+      cleanup_old_versions(versions, version_count)
+    end
+
+    # Remove old versions of an application
+    # @param versions [Array<String>] list of version directories
+    # @param total_count [Integer] total number of versions
+    def cleanup_old_versions(versions, total_count)
+      sorted_versions = versions.sort_by { |dir| File.mtime(dir) }
+      versions_to_delete = total_count - @retain_count
+      sorted_versions[0, versions_to_delete].each do |dir|
+        logger.info("Removing #{dir}", mtime: File.mtime(dir))
+        FileUtils.rm_rf(dir)
+      end
+    end
+  end
+end

data/lib/kscript/plugins/kk_es_fingerprint_utils.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+# Copyright (c) 2025 Kk
+#
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+require 'kscript'
+
+module Kscript
+  class KkEsFingerprintUtils < Base
+    DEFAULT_CERT_PATH = 'elasticsearch.crt'
+
+    attr_reader :cert_path
+
+    # Initialize with certificate path
+    # @param cert_path [String] path to the certificate file
+    def initialize(cert_path = DEFAULT_CERT_PATH)
+      @cert_path = cert_path
+    end
+
+    def run
+      with_error_handling do
+        generate
+      end
+    end
+
+    def self.arguments
+      '<cert_file>'
+    end
+
+    def self.usage
+      "kscript es_fingerprint <cert_file>\nkscript es_fingerprint ./ca.crt"
+    end
+
+    def self.group
+      'elastic'
+    end
+
+    def self.author
+      'kk'
+    end
+
+    def self.description
+      'Generate Elasticsearch certificate SHA256 fingerprint.'
+    end
+
+    private
+
+    # Generate and display the certificate fingerprint
+    def generate
+      validate_certificate_file
+      cert = load_certificate
+      fingerprint = calculate_fingerprint(cert)
+      display_fingerprint(fingerprint)
+    end
+
+    # Validate certificate file existence
+    def validate_certificate_file
+      return if File.exist?(cert_path)
+
+      raise "Certificate file not found: #{cert_path}"
+    end
+
+    # Load X509 certificate from file
+    # @return [OpenSSL::X509::Certificate] loaded certificate
+    def load_certificate
+      OpenSSL::X509::Certificate.new(File.read(cert_path))
+    end
+
+    # Calculate SHA256 fingerprint
+    # @param cert [OpenSSL::X509::Certificate] certificate to process
+    # @return [String] formatted fingerprint
+    def calculate_fingerprint(cert)
+      raw_fingerprint = OpenSSL::Digest::SHA256.hexdigest(cert.to_der)
+      format_fingerprint(raw_fingerprint)
+    end
+
+    # Format fingerprint with colons
+    # @param fingerprint [String] raw fingerprint
+    # @return [String] formatted fingerprint
+    def format_fingerprint(fingerprint)
+      fingerprint.scan(/../).join(':').upcase
+    end
+
+    # Display the formatted fingerprint
+    # @param fingerprint [String] formatted fingerprint to display
+    def display_fingerprint(fingerprint)
+      logger.kinfo(fingerprint)
+    end
+  end
+end

data/lib/kscript/plugins/kk_ffmpeg_utils.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+# Copyright (c) 2025 Kk
+#
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+require 'kscript'
+
+module Kscript
+  class KkFfmpegUtils < Base
+    def run
+      with_error_handling do
+        install
+      end
+    end
+
+    def install
+      logger.kinfo('FFmpeg installer executed.')
+    end
+
+    def self.arguments
+      '[version]'
+    end
+
+    def self.usage
+      "kscript ffmpeg 6.0\nkscript ffmpeg latest"
+    end
+
+    def self.group
+      'media'
+    end
+
+    def self.author
+      'kk'
+    end
+
+    def self.description
+      'Install and verify FFmpeg on Linux.'
+    end
+
+    private
+
+    # Detect OS family and version
+    # @return [Hash] OS family and version information
+    def detect_os_info
+      content = File.read('/etc/os-release')
+      {
+        family: detect_os_family(content),
+        version: detect_os_version(content)
+      }
+    end
+
+    # Detect OS family from os-release content
+    # @param content [String] contents of os-release file
+    # @return [String] OS family name
+    def detect_os_family(content)
+      if content =~ /ID_LIKE=.*rhel|centos|fedora/i || content =~ /ID=.*(rhel|centos|rocky|alma|fedora)/i
+        'redhat'
+      elsif content =~ /ID_LIKE=.*debian/i || content =~ /ID=.*(debian|ubuntu)/i
+        'debian'
+      else
+        'unknown'
+      end
+    end
+
+    # Detect OS version from os-release content
+    # @param content [String] contents of os-release file
+    # @return [Integer] major version number
+    def detect_os_version(content)
+      version_str = content[/VERSION_ID="?([\d.]+)"?/, 1] || '0'
+      version_str.split('.').first.to_i
+    end
+
+    # Update system package lists
+    def update_system
+      logger.kinfo('👉 Updating system packages...')
+      case @os_info[:family]
+      when 'redhat'
+        run_command('sudo yum update -y')
+      when 'debian'
+        run_command('sudo apt update -y')
+      end
+    end
+
+    # Install prerequisite repositories
+    def install_prerequisites
+      return unless @os_info[:family] == 'redhat'
+
+      install_epel
+      install_rpm_fusion if @os_info[:version].between?(7, 9)
+    end
+
+    # Install EPEL repository
+    def install_epel
+      logger.kinfo('👉 Installing EPEL repository...')
+      run_command('sudo yum install -y epel-release')
+    end
+
+    # Install RPM Fusion repository
+    def install_rpm_fusion
+      logger.kinfo("👉 Installing RPM Fusion repository for EL#{@os_info[:version]}...")
+      run_command("sudo yum install -y https://download1.rpmfusion.org/free/el/rpmfusion-free-release-#{@os_info[:version]}.noarch.rpm")
+    end
+
+    # Install FFmpeg packages
+    def install_ffmpeg
+      logger.kinfo('👉 Installing FFmpeg...')
+      case @os_info[:family]
+      when 'redhat'
+        run_command('sudo yum install -y ffmpeg ffmpeg-devel')
+      when 'debian'
+        run_command('sudo apt install -y ffmpeg')
+      else
+        fail_with_error('Unsupported OS')
+      end
+    end
+
+    # Verify FFmpeg installation
+    def verify_installation
+      logger.kinfo('👉 Verifying FFmpeg installation...')
+      run_command('ffmpeg -version')
+      logger.kinfo('✅ FFmpeg installation completed successfully!')
+    end
+
+    # Execute shell command
+    # @param cmd [String] command to execute
+    def run_command(cmd)
+      logger.kinfo("👉 Running: #{cmd}")
+      system(cmd) || fail_with_error("Command failed: #{cmd}")
+    end
+
+    # Display error and exit
+    # @param msg [String] error message
+    def fail_with_error(msg)
+      logger.kerror("❌ #{msg}")
+      exit 1
+    end
+  end
+end

data/lib/kscript/plugins/kk_ip_utils.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+# Copyright (c) 2025 Kk
+#
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+require 'kscript'
+
+require 'http'
+require 'json'
+
+module Kscript
+  class KkIpUtils < Base
+    IP_API_BASE_URL = 'http://ip-api.com/json'
+    IP_CHECK_URL = 'https://api.ipify.org?format=json'
+
+    attr_reader :ip_address
+
+    def initialize(ip_address = nil, *_args, **opts)
+      super(**opts.merge(service: 'kk_ip_api'))
+      @ip_address = ip_address || fetch_public_ip
+    end
+
+    def run
+      with_error_handling do
+        fetch_location
+      end
+    end
+
+    def fetch_location
+      validate_ip_address!
+      response = make_api_request
+      handle_response(response)
+    end
+
+    def self.arguments
+      '<ip_address>'
+    end
+
+    def self.usage
+      "kscript ip <ip_address>\nkscript ip 8.8.8.8"
+    end
+
+    def self.group
+      'network'
+    end
+
+    def self.author
+      'kk'
+    end
+
+    def self.description
+      'Query IP geolocation and ISP info.'
+    end
+
+    private
+
+    def fetch_public_ip
+      response = HTTP.get(IP_CHECK_URL)
+      raise "Failed to detect public IP: #{response.status}" unless response.status.success?
+
+      data = JSON.parse(response.body.to_s)
+      logger.info("Detected public IP: #{data['ip']}")
+      data['ip']
+    end
+
+    def validate_ip_address!
+      return if valid_ip_format?
+
+      raise ArgumentError, 'Invalid IP address format'
+    end
+
+    def valid_ip_format?
+      /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.match?(@ip_address)
+    end
+
+    def make_api_request
+      HTTP.get("#{IP_API_BASE_URL}/#{@ip_address}")
+    end
+
+    def handle_response(response)
+      if response.status.success?
+        logger.kinfo('IP location result', data: response.parse(:json))
+      else
+        logger.kerror("API request failed: #{response.status}")
+      end
+    end
+  end
+end

data/lib/kscript/plugins/kk_jenkins_utils.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+# Copyright (c) 2025 Kk
+#
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+require 'kscript'
+require 'http'
+require 'base64'
+require 'rexml/document'
+require 'json'
+require 'fileutils'
+require 'kscript/base'
+
+module Kscript
+  class KkJenkinsUtils < Base
+    def run
+      with_error_handling do
+        logger.kinfo('Jenkins job manager executed.')
+      end
+    end
+
+    def initialize(jenkins_url, user, password)
+      @jenkins_url = jenkins_url
+      @user = user
+      @password = password
+      @auth_header = "Basic #{Base64.strict_encode64("#{@user}:#{@password}")}"
+      @output = $stdout
+      @output.sync = true
+    end
+
+    def export_all_jobs
+      FileUtils.mkdir_p('jobs')
+
+      job_names = get_all_job_names
+      job_names.each do |job_name|
+        config_xml = export_job(job_name)
+        if config_xml
+          File.write("jobs/#{job_name}.xml", config_xml)
+          logger.kinfo("Exported job: #{job_name}")
+        end
+      end
+    end
+
+    def import_job_from_file(job_name)
+      file_path = "jobs/#{job_name}.xml"
+      if File.exist?(file_path)
+        config_xml = File.read(file_path)
+        import_or_update_job(job_name, config_xml)
+      else
+        logger.kerror("Job file #{file_path} does not exist!")
+      end
+    end
+
+    def import_all_jobs_from_files
+      job_files = Dir.glob('jobs/*.xml')
+      job_files.each do |file_path|
+        job_name = File.basename(file_path, '.xml')
+        logger.kinfo("Importing or updating job: #{job_name}")
+        config_xml = File.read(file_path)
+        import_or_update_job(job_name, config_xml)
+      end
+    end
+
+    def get_all_job_names
+      url = "#{@jenkins_url}/api/json?tree=jobs[name]"
+      response = HTTP.get(url, headers: { 'Authorization' => @auth_header })
+      if response.status.success?
+        jobs = JSON.parse(response.body.to_s)['jobs']
+        jobs.map { |job| job['name'] }
+      else
+        logger.kerror("Error fetching job list: #{response.status}")
+        []
+      end
+    rescue StandardError => e
+      logger.kerror("Exception fetching job list: #{e.message}")
+      []
+    end
+
+    def export_job(job_name)
+      url = "#{@jenkins_url}/job/#{job_name}/config.xml"
+      response = HTTP.get(url, headers: { 'Authorization' => @auth_header })
+      return response.body.to_s if response.status.success?
+
+      logger.kerror("Error exporting job #{job_name}: #{response.status}")
+      nil
+    rescue StandardError => e
+      logger.kerror("Exception exporting job #{job_name}: #{e.message}")
+      nil
+    end
+
+    def import_or_update_job(job_name, config_xml)
+      url = "#{@jenkins_url}/job/#{job_name}/config.xml"
+      logger.kinfo(url)
+      begin
+        logger.kinfo("Creating new job #{job_name}")
+        create_new_job(job_name, config_xml)
+      rescue StandardError
+        logger.kinfo("Updating existing job #{job_name}")
+        HTTP.put(url, body: config_xml, headers: {
+                   'Authorization' => @auth_header,
+                   'Content-Type' => 'application/xml'
+                 })
+      end
+    end
+
+    def self.arguments
+      '[subcommand] [options]'
+    end
+
+    def self.usage
+      "kscript jenkins list --host=jenkins.local\nkscript jenkins trigger --job=build"
+    end
+
+    def self.group
+      'ci'
+    end
+
+    def self.author
+      'kk'
+    end
+
+    def self.description
+      'Jenkins job export/import automation.'
+    end
+
+    private
+
+    def create_new_job(job_name, config_xml)
+      url = "#{@jenkins_url}/createItem?name=#{job_name}"
+      response = HTTP.post(url, body: config_xml, headers: {
+                             'Authorization' => @auth_header,
+                             'Content-Type' => 'application/xml'
+                           })
+      if response.status.success?
+        logger.kinfo("Successfully created new job #{job_name}")
+      else
+        logger.kerror("Failed to create job #{job_name}: #{response.status}")
+      end
+    end
+  end
+end