krakenlab 2018.01.07

data/lib/kraken.rb

@@ -0,0 +1,15 @@
+require 'kraken/version'
+
+# Main module from Kraken Framework
+module Kraken
+end
+
+require 'kraken/core/client'
+require 'kraken/core/config'
+require 'kraken/core/listener'
+require 'kraken/core/log'
+require 'kraken/core/app'
+
+require 'kraken/models/model'
+
+require 'kraken/triggers/trigger'

data/lib/kraken/constants/project.rb

@@ -0,0 +1,64 @@
+module Kraken
+  APP_FILE = "require 'yaml'\n
+Kraken::Config.instance.setup do |config|
+  config.server name: 'app name', version: '1.0', handler: :godot_30
+  config.add_trigger klass: Kraken::Trigger
+end\n
+Kraken::Migrations.configure do |c|
+  c.schema_format = :ruby
+  c.db_dir = 'db'
+  c.yaml_config = 'config/db.yml'
+  c.migrations_paths = ['db/migrate']
+end
+".freeze
+
+  CONNECTION_FILE = "class Kraken::Connection < Kraken::MemoryModel
+  def on_delete; end\n
+  def authenticate
+    true
+  end
+end".freeze
+
+  DB_FILE = "server:
+  adapter: postgresql
+  database: kraken
+  encoding: utf8
+  host: localhost
+  username: postgres
+  password: postgres".freeze
+
+  RAKEFILE_FILE = "require 'kraken'\n
+Kraken::App.load_app
+Kraken::Migrations.load_tasks\n
+task :default do
+  sh 'bundle exec kraken -s'
+end\n
+task :console do
+  sh 'bundle exec kraken -d'
+end\n
+task :test do
+  sh 'rubocop'
+  sh 'bundle exec rspec'
+end\n
+task :migrate do
+  sh 'bundle exec kraken -m'
+end".freeze
+
+  GEMFILE_FILE = "source 'https://rubygems.org' do
+	gem 'krakenlab', '#{Kraken::VERSION}'\n
+  gem 'rspec'
+  gem 'rubocop'
+end
+".freeze
+
+  GITIGNORE_FILE = '*.lock'.freeze
+
+  PROJECT_TREE = {
+    'app' => { 'triggers' => {}, 'validators' => {}, 'models' => { 'database' => {}, 'memory' => {} } },
+    'config' => { 'app.rb' => APP_FILE, 'connection.rb' => CONNECTION_FILE, 'db.yml' => DB_FILE },
+    'db' => { 'seeds.rb' => '', 'migrate' => {} },
+    'Rakefile' => RAKEFILE_FILE,
+    'Gemfile' => GEMFILE_FILE,
+    '.gitignore' => GITIGNORE_FILE
+  }.freeze
+end

data/lib/kraken/core/app.rb

@@ -0,0 +1,46 @@
+require 'irb'
+require 'require_all'
+require 'project_creator'
+require 'kraken/constants/project'
+
+module Kraken
+  # This class are used for load and create kraken applications!
+  class App
+    def self.load_app
+      require_all 'app/validators' if File.exist? 'app/validators'
+      require_all 'app' if File.exist? 'app'
+      require_all 'config' if File.exist? 'config'
+    end
+
+    def self.create_app(name)
+      { name.to_s => PROJECT_TREE }.create_project
+      exit 0
+    end
+
+    def self.print_version
+      puts 'KrakenLab'
+      puts "-v #{Kraken::VERSION}"
+      exit 0
+    end
+
+    def self.print_help
+      print_version
+      puts 'kraken -n app_name: Create a new kraken app'
+      puts 'kraken -s: start the created app'
+      puts 'kraken -v: show the version'
+      puts 'kraken -d: start a console'
+      puts ''
+
+      puts 'rake db:* for migrations operations. See more about ActiveRecord'
+    end
+
+    def self.start_console
+      IRB.start(__FILE__)
+      exit 0
+    end
+
+    def self.start_server
+      Kraken::Listener.new.join
+    end
+  end
+end

data/lib/kraken/core/client.rb

@@ -0,0 +1,108 @@
+require 'socket'
+
+module Kraken
+  # A simple client for KrakenLab server.
+  # You can use this class to Debug the server with `kraken -c`
+  # or implements your game using gosu gem!
+  #
+  #   a = Kraken::Client.new 'user', 'pass'
+  #   a.connect 'localhost'
+  #   a.call 'module::krakentrigger', {a: 2, b: [2,3,4], c: 'haha'}
+  #   a.call 'module::krakentrigger', 'call only this'
+  #   a.call 'module::krakentrigger', ['or this', 3]
+  class Client
+    def initialize(user, pass, version)
+      @user = user
+      @pass = pass
+      @version = version
+    end
+
+    def close
+      @socket.close unless @socket.nil?
+    end
+
+    def connect(host, port = 3030)
+      @socket = TCPSocket.new(host, port)
+      write @version
+      write @user
+      write @pass
+      raise 'connection refused' unless read == 'ok'
+    rescue StandardError
+      raise 'connection refused'
+    end
+
+    def call(method, params)
+      write method
+      write to_args(params)
+      read_args
+    end
+
+    private
+
+    def read
+      r = @socket.gets
+      raise 'connection lost' if r.nil?
+      r.chomp
+    end
+
+    def read_args
+      type = read
+      case type
+      when 'h'
+        return read_hash
+      when 'v'
+        return read_vector
+      when 'n'
+        return nil
+      when 'a'
+        return read
+      end
+    end
+
+    def read_hash
+      n = read.to_i
+      awns = {}
+      n.times { awns[read.to_sym] = read_args }
+      awns
+    end
+
+    def read_vector
+      n = read.to_i
+      awns = []
+      n.times { awns << read_args }
+      awns
+    end
+
+    def write(txt)
+      @socket.puts txt.chomp
+    end
+
+    def to_args(obj)
+      case obj
+      when Hash
+        return "h\n#{obj.size}\n#{hash_protocol obj}"
+      when Array
+        return "v\n#{obj.size}\n#{vector_protocol obj}"
+      when NilClass
+        return 'n'
+      end
+      absolute_value(obj)
+    end
+
+    def hash_protocol(obj)
+      ret = ''
+      obj.each_pair { |key, value| ret += "#{key}\n#{to_args value}\n" }
+      ret.chomp
+    end
+
+    def vector_protocol(obj)
+      ret = ''
+      obj.each { |value| ret += "#{to_args value}\n" }
+      ret.chomp
+    end
+
+    def absolute_value(obj)
+      "a\n#{obj}"
+    end
+  end
+end

data/lib/kraken/core/config.rb

@@ -0,0 +1,39 @@
+require 'singleton'
+
+module Kraken
+  # Configure the kraken framework.
+  # You can configure the server, postgre and redis.
+  # You can configure the events in server.
+  # Yes! You can configure other plugins here!
+  #
+  #    Kraken::Config.instance.setup do |config|
+  #        config.server name: 'hehe'
+  #    end
+  class Config
+    include Singleton
+
+    attr_reader :server_name, :server_version, :server_handler
+    attr_reader :triggers
+
+    def setup
+      yield self
+    end
+
+    def server(name: 'kraken app', version: 'valid version', handler: :default)
+      @server_name = name
+      @server_version = version
+
+      raise 'invalid parser' unless HANDLERS.include? handler
+
+      @server_handler = handler
+    end
+
+    def add_trigger(klass: Kraken::Trigger)
+      raise 'Klass needs to inherit Kraken::Trigger' unless klass <= Kraken::Trigger
+
+      @triggers ||= {}
+      @triggers[klass.to_s.downcase] = klass
+      Kraken::Log.info "trigger [#{klass.to_s.downcase}] loaded"
+    end
+  end
+end

data/lib/kraken/core/connection.rb

@@ -0,0 +1,21 @@
+require 'kraken/models/model'
+
+module Kraken
+  # The most trivial node
+  class Connection < MemoryModel
+    attribute :user
+    attribute :pass
+
+    index :user
+
+    # How are defined it is a uniq user authenticated in Kraken Network
+    def single_user?
+      Kraken::Connection.find(user: user).size <= 1
+    end
+
+    # Validate if the credentials are correct
+    def authenticate
+      true
+    end
+  end
+end

data/lib/kraken/core/handlers/factory.rb

@@ -0,0 +1,14 @@
+require 'kraken/core/handlers/handler'
+require 'kraken/core/handlers/godot30_handler'
+
+module Kraken
+  # This class create the handler defined at Config
+  class HandlerFactory
+    def self.create(socket)
+      parser = Kraken::Config.instance.server_handler
+
+      return Kraken::Godot30Handler.new(socket) if parser == :godot_30
+      Kraken::Handler.new(socket)
+    end
+  end
+end

data/lib/kraken/core/handlers/godot30_handler.rb

@@ -0,0 +1,16 @@
+require 'kraken/core/handlers/handler'
+
+module Kraken
+  # This class made the handler with godot 3.0
+  # To use this handler, setup this line in config file:
+  # config.server name: 'app name', version: '1.0', handler: :godot_30
+  class Godot30Handler < Kraken::Handler
+    def read
+      string_length = @socket.read(4).unpack('L<').first
+      raise 'connection lost' if string_length.nil?
+      line = @socket.read(string_length)
+      raise 'connection lost' if line.nil?
+      line.chomp
+    end
+  end
+end

data/lib/kraken/core/handlers/handler.rb

@@ -0,0 +1,150 @@
+require 'socket'
+require 'thread'
+
+require 'kraken/core/connection'
+
+module Kraken
+  HANDLERS = %i[godot_30 default].freeze
+
+  # This class handle a Socket.
+  class Handler
+    attr_accessor :connection
+
+    def initialize(socket)
+      return if socket.nil?
+
+      @socket = socket
+      @thread = Thread.new do
+        begin
+          start
+        rescue StandardError => e
+          Kraken::Log.error e
+          close
+        end
+      end
+    end
+
+    def close
+      @connection.delete unless @connection.nil?
+
+      Kraken::Log.info 'bye bye socket'
+
+      @socket.close
+      @thread.kill
+    end
+
+    def read_trigger
+      trigger = read
+      args = read_args
+      [Kraken::Config.instance.triggers[trigger.downcase], args]
+    end
+
+    private
+
+    def start
+      version, user, pass = read_authentication_info
+
+      raise 'invalid version' unless Kraken::Config.instance.server_version == version
+
+      @connection = Connection.create(user: user, pass: pass)
+      @connection.save
+
+      raise 'only one connection by user' unless @connection.single_user?
+
+      if @connection.authenticate
+        write 'ok'
+      else
+        write 'nop'
+        raise 'can not authenticate'
+      end
+
+      work
+      close
+    end
+
+    def read_authentication_info
+      version = read
+      user = read
+      pass = read
+      [version, user, pass]
+    end
+
+    def work
+      loop do
+        trigger, args = read_trigger
+
+        shot = trigger.new(self, args)
+        shot.run
+        callback = shot.callback
+
+        write to_args(callback)
+      end
+    end
+
+    def read
+      r = @socket.gets
+      raise 'connection lost' if r.nil?
+      r.chomp
+    end
+
+    def read_args
+      type = read
+      case type
+      when 'h'
+        return read_hash
+      when 'v'
+        return read_vector
+      when 'n'
+        return nil
+      when 'a'
+        return read
+      end
+    end
+
+    def read_hash
+      n = read.to_i
+      awns = {}
+      n.times { awns[read.to_sym] = read_args }
+      awns
+    end
+
+    def read_vector
+      n = read.to_i
+      awns = []
+      n.times { awns << read_args }
+      awns
+    end
+
+    def write(txt)
+      @socket.puts txt.chomp
+    end
+
+    def to_args(obj)
+      case obj
+      when Hash
+        return "h\n#{obj.size}\n#{hash_protocol obj}"
+      when Array
+        return "v\n#{obj.size}\n#{vector_protocol obj}"
+      when NilClass
+        return 'n'
+      end
+      absolute_value(obj)
+    end
+
+    def hash_protocol(obj)
+      ret = ''
+      obj.each_pair { |key, value| ret += "#{key}\n#{to_args value}\n" }
+      ret.chomp
+    end
+
+    def vector_protocol(obj)
+      ret = ''
+      obj.each { |value| ret += "#{to_args value}\n" }
+      ret.chomp
+    end
+
+    def absolute_value(obj)
+      "a\n#{obj}"
+    end
+  end
+end