gack 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 332de1b51ed8daf7f6d759c03df4140612328e83b107aa51accc8a7f09097377
+  data.tar.gz: b4b74b3ce6ae1ded331c7ecc0799b3e40e86a98b068c15dc967e208e1b97b30c
+SHA512:
+  metadata.gz: dc0d59152ad07d7955109438e174e27bf408d6872d864aa46fff496a5d4c165505460a90110bf09d81411b604bd818357977d8483580d5fe8c170de8d19bfadf
+  data.tar.gz: 177c947803a4584279d15135e961115f5f2d64cbfbebcf7dd2efa7ecdbf6c1f3d1cf200ee3dd5bc5748855db17ec7ec4532e4102cee24628ba658c93a0b81a60

data/README.md

@@ -0,0 +1,53 @@
+# Gack
+
+Gack helps you build [Gemini](https://gemini.circumlunar.space/) protocol applications with Ruby.
+
+## Usage
+
+Install gem:
+
+    gem install gack
+
+See examples for more details: [Examples](./examples/)
+
+### TLS
+
+Gemini requires TLS handshakes. Gack does not do TLS handshakes. You need to setup a TLS terminator. I use Nginx. Below is some quick information on how you might begin to use Nginx to terminate TLS.
+
+#### Certs
+
+Generate a self-signed `.crt` and `.key`. Example:
+
+    openssl req -newkey rsa:2048 -nodes -keyout localhost.key -nodes -x509 -out localhost.crt -subj "/CN=localhost"
+
+#### Nginx
+
+Nginx will be used for the TLS handshake and termination:
+
+    stream {
+
+      upstream backend {
+        # change this to reflect what port your Gack server is running on (default is 6565)
+        server localhost:6565;
+      }
+
+      server {
+        # 195 is the default Gemini protocol port
+        listen 1965 ssl;
+        proxy_pass backend;
+
+        # change these to match the directory and filename of your crt and key
+        ssl_certificate     /your/localtion/to/certs/localhost.crt;
+        ssl_certificate_key /your/localtion/to/localhost.key;
+
+        ssl_protocols TLSv1.1 TLSv1.2;
+
+        ssl_prefer_server_ciphers on;
+        ssl_ciphers ECDH+AESGCM:ECDH+AES256:ECDH+AES128:DH+3DES:!ADH:!AECDH:!MD5;
+
+        ssl_session_cache    shared:SSL:20m;
+        ssl_session_timeout  4h;
+
+        ssl_handshake_timeout 20s;
+      }
+    }

data/gack.gemspec

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative 'lib/gack/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'gack'
+  s.version     = Gack::VERSION.dup
+  s.date        = '2020-11-10'
+  s.summary     = 'Basic Gemini server'
+  s.description = 'Gack helps you build Gemini protocol applications with Ruby.'
+  s.authors     = ['Robert Peterson']
+  s.email       = 'me@robertp.me'
+  s.files       = Dir['README.md', 'gack.gemspec', 'lib/**/*']
+  s.homepage    = 'https://github.com/rawburt/gack'
+  s.license     = 'MIT'
+
+  s.required_ruby_version = '>= 2.6.0'
+
+  s.add_development_dependency 'bundler', '~> 2.1'
+  s.add_development_dependency 'rspec', '~> 3.10'
+  s.add_development_dependency 'rubocop', '~> 1.2'
+  s.add_development_dependency 'rubocop-rspec', '~> 2.0'
+  s.add_development_dependency 'simplecov', '~> 0.19'
+end

data/lib/gack.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative 'gack/version'
+require_relative 'gack/logger'
+require_relative 'gack/request'
+require_relative 'gack/response'
+require_relative 'gack/server'
+require_relative 'gack/sphere'
+require_relative 'gack/capsule'

data/lib/gack/capsule.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Gack
+  # The main DSL for making Gemini apps with Gack
+  class Capsule
+    def self.sphere(path, &handler)
+      spheres << Gack::Sphere.new(path, &handler)
+    end
+
+    def self.spheres
+      @spheres ||= []
+    end
+
+    def self.run!
+      new(spheres).run!
+    end
+
+    attr_reader :spheres
+
+    def initialize(spheres)
+      @spheres = spheres
+    end
+
+    def run!
+      server = Gack::Server.new
+      server.event_loop do |request|
+        server_loop_handler(request)
+      end
+    end
+
+    def server_loop_handler(request)
+      sphere = match_sphere(request.location)
+      if sphere
+        result = sphere.handle_request(request)
+        if result.is_a?(Response)
+          result
+        else
+          Response.new(Response::StatusCodes::SUCCESS, Response::MIME[:text], result)
+        end
+      else
+        Response.new(Response::StatusCodes::NOT_FOUND)
+      end
+    end
+
+    def match_sphere(location)
+      spheres.find { |s| s.path_match?(location) }
+    end
+  end
+end

data/lib/gack/logger.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module Gack
+  Logger = Logger.new($stdout)
+end

data/lib/gack/request.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Gack
+  # Parse a Gemini request into a friendly object
+  class Request
+    PROTOCOL = 'gemini://'
+
+    attr_reader :request
+
+    def initialize(request)
+      @request = request
+    end
+
+    def location
+      @location ||= parse_location
+    end
+
+    def input
+      @input ||= parse_input
+    end
+
+    private
+
+    def parse_location
+      # ignore input
+      location_only = clean_request.split('?').first
+
+      return unless location_only
+
+      split_request = location_only.split('/')
+
+      return '/' if split_request.size == 1
+
+      return "/#{split_request.last}" if split_request.size == 2
+
+      "/#{split_request[1..-1].join('/')}"
+    end
+
+    def parse_input
+      split_input = clean_request.split('?')
+
+      if split_input.size > 2
+        CGI.unescape(split_input[1..-1].join('?'))
+      else
+        CGI.unescape(split_input.last)
+      end
+    end
+
+    # `.chomp` to drop the trailing \r\n and `.gsub` to remove the protocol
+    def clean_request
+      @clean_request ||= request.chomp.gsub(PROTOCOL, '')
+    end
+  end
+end

data/lib/gack/response.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative 'response/status_codes'
+
+module Gack
+  # Build a Gemini response
+  class Response
+    InvalidStatusCodeError = Class.new(StandardError)
+    BodyNotAllowedError = Class.new(StandardError)
+    MetaTooLongError = Class.new(StandardError)
+    InvalidMimeError = Class.new(StandardError)
+
+    META_MAX_BYTES = 1024
+
+    MIME = {
+      text: 'text/gemini'
+    }.freeze
+
+    attr_reader :status_code, :meta, :body
+
+    def initialize(status_code, meta = nil, body = nil)
+      @status_code = Integer(status_code)
+
+      raise InvalidStatusCodeError unless StatusCodes::VALID_CODES.include?(@status_code)
+
+      @meta = meta
+
+      raise MetaTooLongError if @meta && @meta.bytesize > META_MAX_BYTES
+      raise InvalidMimeError if @status_code == StatusCodes::SUCCESS && @meta.nil?
+
+      @body = body
+
+      raise BodyNotAllowedError if @body && @status_code != StatusCodes::SUCCESS
+    end
+
+    def finalize
+      return "#{status_code}\r\n" unless meta
+
+      "#{status_code} #{meta}\r\n#{body}"
+    end
+  end
+end

data/lib/gack/response/status_codes.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Gack
+  class Response
+    # Gemini Response Status Codes
+    class StatusCodes
+      # Inputs. <META> = prompt text
+      INPUT = 10
+      SENSITIVE_INPUT = 11
+
+      # Success. <META> = MIME. <BODY>
+      SUCCESS = 20
+
+      # Redirect. <META> = URL
+      REDIRECT_TEMPORARY = 30
+      REDIRECT_PERMANANT = 31
+
+      # Temporary Failure. <META> = additional information
+      TEMPORARY_FAILURE = 40
+      SERVER_UNAVAILABLE = 41
+      CGI_ERROR = 42
+      PROXY_ERROR = 43
+      SLOW_DOWN = 44
+
+      # Permanent Failure. <META> = additional information
+      PERMANENT_FAILURE = 50
+      NOT_FOUND = 51
+      GONE = 52
+      PROXY_REQUEST_REFUSED = 53
+      BAD_REQUEST = 59
+
+      # Client Certificate Requires. <META> = additional information
+      CLIENT_CERTIFICATE_REQUIRED = 60
+      CERTIFICATE_NOT_AUTHORIZED = 61
+      CERTIFICATE_NOT_VALID = 62
+
+      VALID_CODES = [
+        INPUT,
+        SENSITIVE_INPUT,
+        SUCCESS,
+        REDIRECT_TEMPORARY,
+        REDIRECT_PERMANANT,
+        TEMPORARY_FAILURE,
+        SERVER_UNAVAILABLE,
+        CGI_ERROR,
+        PROXY_ERROR,
+        SLOW_DOWN,
+        PERMANENT_FAILURE,
+        NOT_FOUND,
+        GONE,
+        PROXY_REQUEST_REFUSED,
+        BAD_REQUEST,
+        CLIENT_CERTIFICATE_REQUIRED,
+        CERTIFICATE_NOT_AUTHORIZED,
+        CERTIFICATE_NOT_VALID
+      ].freeze
+    end
+  end
+end

data/lib/gack/server.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: false
+
+require 'socket'
+
+module Gack
+  # The main TCP server
+  class Server
+    attr_reader :tcp, :port, :logger
+
+    def initialize(tcp: TCPServer, port: 6565, logger: Gack::Logger)
+      @tcp = tcp
+      @port = port
+      @logger = logger
+    end
+
+    def event_loop(&blk)
+      logger.info("starting. port=#{port}")
+
+      server = tcp.new(port)
+
+      loop do
+        Thread.new(server.accept) do |client|
+          main_handler(client, &blk)
+        end
+      end
+    rescue StandardError => e
+      logger.error(e)
+    end
+
+    def main_handler(client, &blk)
+      unrescued_handler(client, &blk)
+    rescue StandardError => e
+      logger.error(e)
+
+      failure_response.finalize
+    end
+
+    def unrescued_handler(client, &blk)
+      raw_request = receive_request(client)
+
+      request = Request.new(raw_request)
+
+      logger.info("request received: #{request.location}")
+
+      response = blk.call(request)
+
+      logger.info("response: #{response.status_code}")
+
+      client.puts(response.finalize)
+      client.close
+    end
+
+    def failure_response
+      Response.new(Response::StatusCodes::TEMPORARY_FAILURE, 'Server Error')
+    end
+
+    private
+
+    def receive_request(client)
+      request = ''
+      begin
+        client.read_nonblock(2056, request)
+      rescue IO::WaitReadable
+        IO.select([client])
+        retry
+      end
+      request
+    end
+  end
+end

data/lib/gack/sphere.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Gack
+  # Sphere is a Gemini request handler wrapper for a given path
+  class Sphere
+    HandlerMissingError = Class.new(StandardError)
+
+    attr_reader :path, :handler
+
+    def initialize(path, &handler)
+      @path = path
+
+      raise HandlerMissingError unless handler
+
+      @handler = handler
+    end
+
+    def path_match?(string)
+      if path.is_a?(Regexp)
+        path.match?(string)
+      else
+        path.eql?(string)
+      end
+    end
+
+    def handle_request(request)
+      handler.call(request)
+    end
+  end
+end

data/lib/gack/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Gack
+  VERSION = '0.0.1'
+end

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification
+name: gack
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Robert Peterson
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2020-11-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.10'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+description: Gack helps you build Gemini protocol applications with Ruby.
+email: me@robertp.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- gack.gemspec
+- lib/gack.rb
+- lib/gack/capsule.rb
+- lib/gack/logger.rb
+- lib/gack/request.rb
+- lib/gack/response.rb
+- lib/gack/response/status_codes.rb
+- lib/gack/server.rb
+- lib/gack/sphere.rb
+- lib/gack/version.rb
+homepage: https://github.com/rawburt/gack
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key:
+specification_version: 4
+summary: Basic Gemini server
+test_files: []