planetscale 0.1.0

data/lib/generators/planetscale/install_generator.rb

@@ -0,0 +1,58 @@
+require 'rails/generators'
+
+class Planetscale
+  class InstallGenerator < Rails::Generators::Base    
+    class_option :organization, type: :string, default: ''
+
+    def read_config
+      @database = "<db_name>"
+      file_path = File.join(Rails.root, PlanetScale::Proxy::PSCALE_FILE)
+      return unless File.exist?(file_path)
+
+      data = YAML.safe_load(File.read(file_path))
+      @database = data['database']
+      @org = data['org']
+    end
+
+    def check_org
+      if options[:organization].empty? && @org.nil?
+        puts "Usage: bundle exec rails g planetscale:install --organization ORG_NAME"
+        abort
+      end
+
+      @org ||= options[:organization]
+    end 
+
+    def create_planetscale_config
+      create_file "config/planetscale.rb", "PlanetScale.start(org: '#{@org}')\n"
+      inject_into_file "config/environment.rb", after: "require_relative \"application\"\n" do <<~'RUBY'
+        require_relative "planetscale"
+      RUBY
+      end
+    end
+
+    # todo(nickvanw): When we get rid of DB passwords, this can mostly go away, and we can just
+    # return the `DATABSE_URL` that the user should use. 
+    def print_database_yaml
+      d =
+      <<~EOS
+      development:
+        <<: *default
+        username: root
+        host: 127.0.0.1
+        port: 3305
+        database: #{@database}
+      EOS
+
+
+      db_url = "mysql2://root:@127.0.0.1:3305/#{@database}"
+      puts "Installed!\n\nConfigure your database.yaml like so:\n".bold
+      puts d
+      puts "\nOr set DATABASE_URL=#{db_url}"
+    end
+  end 
+end
+
+class String
+  def bold; "\e[1m#{self}\e[22m" end
+end

data/lib/planetscale.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require 'planetscale/version'
+require 'ffi'
+
+module PlanetScale
+  class <<self
+    def start(auth_method: Proxy::AUTH_AUTO, **kwargs)
+      @proxy = PlanetScale::Proxy.new(auth_method: auth_method, **kwargs)
+      @proxy.start
+    end
+  end
+
+  class Proxy
+    AUTH_SERVICE_TOKEN = 1 # Use Service Tokens for Auth
+    AUTH_PSCALE = 2 # Use externally configured `pscale` auth & org config
+    AUTH_STATIC = 3 # Use a locally provided certificate
+    AUTH_AUTO = 4 # Default. Let the Gem figure it out
+    PSCALE_FILE = '.pscale.yml'
+
+    class ProxyError < StandardError
+    end
+
+    extend FFI::Library
+
+    class ProxyReturn < FFI::Struct
+      layout :r0, :pointer, :r1, :pointer
+    end
+
+    ffi_lib File.expand_path("../../proxy/planetscale-#{Gem::Platform.local.os}.so", __FILE__)
+    attach_function :startfromenv, %i[string string string string], ProxyReturn.by_value
+    attach_function :startfromtoken, %i[string string string string string string], ProxyReturn.by_value
+    attach_function :startfromstatic, %i[string string string string string string string string string], ProxyReturn.by_value
+
+    def initialize(auth_method: AUTH_AUTO, **kwargs)
+      @auth_method = auth_method
+
+      default_file = if defined?(Rails.root)
+        File.join(Rails.root, PSCALE_FILE) if defined?(Rails.root)
+      else
+        PSCALE_FILE
+      end
+
+      @cfg_file = kwargs[:cfg_file] || ENV['PSCALE_DB_CONFIG'] || default_file
+
+      @branch_name = kwargs[:branch] || ENV['PSCALE_DB_BRANCH']
+      @branch = lookup_branch
+
+      @db_name = kwargs[:db] || ENV['PSCALE_DB']
+      @db = lookup_database
+
+      @org_name = kwargs[:org] || ENV['PSCALE_ORG']
+      @org = lookup_org
+
+      raise ArgumentError, 'missing required configuration variables' if [@db, @branch, @org].any?(&:nil?)
+
+      @token_name = kwargs[:token_id] || ENV['PSCALE_TOKEN_NAME']
+      @token = kwargs[:token] || ENV['PSCALE_TOKEN']
+
+      if @token && @token_name && auto_auth?
+        @auth_method = AUTH_SERVICE_TOKEN
+      end
+
+      raise ArgumentError, 'missing configured service token auth' if token_auth? && [@token_name, @token].any?(&:nil?)
+
+      @priv_key = kwargs[:private_key]
+      @cert_chain = kwargs[:cert_chain]
+      @remote_addr = kwargs[:remote_addr]
+      @certificate = kwargs[:certificate]
+      @port = kwargs[:port]
+
+      if local_auth? && [@priv_key, @certificate, @cert_chain, @remote_addr, @port].any?(&:nil?)
+        raise ArgumentError, 'missing configuration options for auth'
+      end
+
+      @listen_addr = kwargs[:listen_addr] || ENV['LISTEN_ADDR']
+    end
+
+    def start
+      ret = case @auth_method
+      when AUTH_PSCALE
+        startfromenv(@org, @db, @branch, @listen_addr)
+      when AUTH_AUTO
+        startfromenv(@org, @db, @branch, @listen_addr)
+      when AUTH_SERVICE_TOKEN
+        startfromtoken(@token_name, @token, @org, @db, @branch, @listen_addr)
+      when AUTH_STATIC
+        startfromstatic(@org, @db, @branch, @priv_key, @certificate, @cert_chain, @remote_addr, @port, @listen_addr)
+      end
+      @err = ret[:r1].null? ? nil : ret[:r1].read_string
+      raise(ProxyError, @err) if @err
+    end
+
+    private
+
+    def lookup_branch
+      return @branch_name if @branch_name
+      return nil unless File.exist?(@cfg_file)
+
+      cfg_file['branch']
+    end
+
+    def lookup_database
+      return @db_name if @db_name
+      return nil unless File.exist?(@cfg_file)
+
+      cfg_file['database']
+    end
+
+    def lookup_org
+      return @org_name if @org_name
+      return nil unless File.exist?(@cfg_file)
+
+      cfg_file['org']
+    end
+
+    def cfg_file
+      @cfg ||= YAML.safe_load(File.read(@cfg_file))
+    end
+
+    def local_auth?
+      @auth_method == AUTH_STATIC
+    end
+
+    def env_auth?
+      @auth_method == AUTH_PSCALE
+    end
+
+    def token_auth?
+      @auth_method == AUTH_SERVICE_TOKEN
+    end
+
+    def auto_auth?
+      @auth_method == AUTH_AUTO
+    end
+  end
+end

data/lib/planetscale/version.rb

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

data/planetscale.gemspec

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'planetscale/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'planetscale'
+  spec.version       = PlanetScale::VERSION
+  spec.authors       = ['Nick Van Wiggeren', 'Mike Coutermarsh', 'David Graham']
+  spec.email         = ['nick@planetscale.com']
+
+  spec.summary       = 'Ruby client for PlanetScale Databases'
+  spec.homepage      = 'https://planetscale.com/'
+  spec.license       = 'Apache-2.0'
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['homepage_uri'] = spec.homepage
+    spec.metadata['source_code_uri'] = 'https://github.com/planetscale/planetscale-ruby'
+    spec.metadata['changelog_uri'] = 'https://github.com/planetscale/planetscale-ruby'
+    spec.metadata['github_repo'] = 'ssh://github.com/planetscale/planetscale-ruby'
+  else
+    raise 'RubyGems 2.0 or newer is required to protect against ' \
+      'public gem pushes.'
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) } + Dir.glob("proxy/*")
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 2.2'
+  spec.add_development_dependency 'rake', '>= 12.3.3'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'minitest'
+
+  spec.add_runtime_dependency 'ffi', '~> 1'
+end

data/proxy.go

@@ -0,0 +1,128 @@
+package main
+
+import "C"
+import (
+	"errors"
+	"io/ioutil"
+	"os"
+	"path"
+
+	"github.com/mitchellh/go-homedir"
+	"github.com/planetscale/planetscale-go/planetscale"
+)
+
+const accessTokenDir string = "~/.config/planetscale"
+
+//export startfromenv
+func startfromenv(org, database, branch, listenAddr *C.char) (*C.char, *C.char) {
+	client, err := newClientFromEnv()
+	if err != nil {
+		return nil, nilOrError(err)
+	}
+
+	opts := []controllerOpt{withClient(client)}
+
+	if a := C.GoString(listenAddr); a != "" {
+		opts = append(opts, withListen(a))
+	}
+
+	return startproxy(org, database, branch, opts...)
+}
+
+//export startfromtoken
+func startfromtoken(tokenName, token, org, database, branch, listenAddr *C.char) (*C.char, *C.char) {
+	client, err := newClientFromServiceToken(C.GoString(tokenName), C.GoString(token))
+	if err != nil {
+		return nil, nilOrError(err)
+	}
+
+	opts := []controllerOpt{withClient(client)}
+
+	if a := C.GoString(listenAddr); a != "" {
+		opts = append(opts, withListen(a))
+	}
+
+	return startproxy(org, database, branch, opts...)
+}
+
+//export startfromstatic
+func startfromstatic(org, database, branch, privKey, cert, chain, addr, port, listenAddr *C.char) (*C.char, *C.char) {
+	certSource := &localCertSource{
+		privKey:     C.GoString(privKey),
+		certificate: C.GoString(cert),
+		certChain:   C.GoString(chain),
+		remoteAddr:  C.GoString(addr),
+		port:        C.GoString(port),
+	}
+
+	opts := []controllerOpt{withLocalCertSource(certSource)}
+
+	if a := C.GoString(listenAddr); a != "" {
+		opts = append(opts, withListen(a))
+	}
+
+	return startproxy(org, database, branch, opts...)
+}
+
+func startproxy(org, database, branch *C.char, opts ...controllerOpt) (*C.char, *C.char) {
+	cntrlr, err := newController(C.GoString(org), C.GoString(database), C.GoString(branch), opts...)
+	if err != nil {
+		return nil, nilOrError(err)
+	}
+
+	addr, err := cntrlr.start()
+	return C.CString(addr), nilOrError(err)
+}
+
+func newClientFromEnv() (*planetscale.Client, error) {
+	opts := []planetscale.ClientOption{
+		planetscale.WithBaseURL(planetscale.DefaultBaseURL),
+	}
+
+	token, err := accessToken()
+	if err != nil {
+		return nil, err
+	}
+
+	opts = append(opts, planetscale.WithAccessToken(token))
+
+	return planetscale.NewClient(opts...)
+}
+
+func newClientFromServiceToken(name, token string) (*planetscale.Client, error) {
+	opts := []planetscale.ClientOption{
+		planetscale.WithBaseURL(planetscale.DefaultBaseURL),
+		planetscale.WithServiceToken(name, token),
+	}
+
+	return planetscale.NewClient(opts...)
+}
+
+func accessToken() (string, error) {
+	cfgDir, err := homedir.Expand(accessTokenDir)
+	if err != nil {
+		return "", err
+	}
+	tFile := path.Join(cfgDir, "access-token")
+	if _, err := os.Stat(tFile); err != nil {
+		return "", errors.New("unable to find access token file")
+	}
+
+	t, err := ioutil.ReadFile(tFile)
+	if err != nil {
+		return "", errors.New("unable to read access token file")
+	}
+
+	return string(t), nil
+}
+
+func nilOrError(err error) *C.char {
+	if err == nil {
+		return nil
+	}
+
+	return C.CString(err.Error())
+}
+
+func main() {
+}

data/vendor/github.com/armon/circbuf/.gitignore

@@ -0,0 +1,22 @@
+# Compiled Object files, Static and Dynamic libs (Shared Objects)
+*.o
+*.a
+*.so
+
+# Folders
+_obj
+_test
+
+# Architecture specific extensions/prefixes
+*.[568vq]
+[568vq].out
+
+*.cgo1.go
+*.cgo2.c
+_cgo_defun.c
+_cgo_gotypes.go
+_cgo_export.*
+
+_testmain.go
+
+*.exe

data/vendor/github.com/armon/circbuf/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Armon Dadgar
+
+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/vendor/github.com/armon/circbuf/README.md

@@ -0,0 +1,28 @@
+circbuf
+=======
+
+This repository provides the `circbuf` package. This provides a `Buffer` object
+which is a circular (or ring) buffer. It has a fixed size, but can be written
+to infinitely. Only the last `size` bytes are ever retained. The buffer implements
+the `io.Writer` interface.
+
+Documentation
+=============
+
+Full documentation can be found on [Godoc](http://godoc.org/github.com/armon/circbuf)
+
+Usage
+=====
+
+The `circbuf` package is very easy to use:
+
+```go
+buf, _ := NewBuffer(6)
+buf.Write([]byte("hello world"))
+
+if string(buf.Bytes()) != " world" {
+    panic("should only have last 6 bytes!")
+}
+
+```
+