rubypitaya 1.1.0

data/lib/rubypitaya/app-template/docker-compose.yml

@@ -0,0 +1,75 @@
+version: '3'
+services:
+  nats:
+    image: 'nats:2.1.4'
+    ports:
+      - '4222:4222'
+
+  etcd:
+    image: 'appcelerator/etcd:3.0.15'
+    ports:
+      - '2379:2379'
+      - '2380:2380'
+
+  redis:
+    image: 'redis:3.2.5-alpine'
+    ports:
+      - '9001:6379'
+
+  db:
+    image: 'postgres:9.6.17'
+    volumes:
+      - 'postgres:/var/lib/postgresql/data'
+    environment:
+      POSTGRES_USER: 'postgres'
+      POSTGRES_HOST_AUTH_METHOD: 'trust'
+    ports:
+      - '9100:5432'
+
+  connector:
+    image: 'registry.gitlab.com/lucianopc/pitaya-connector:0.1.0'
+    depends_on:
+      - 'db'
+      - 'nats'
+      - 'etcd'
+      - 'redis'
+    ports:
+      - '3252:3250'
+    environment:
+      PITAYA_CLUSTER_RPC_SERVER_NATS_CONNECT: 'nats://nats:4222'
+      PITAYA_CLUSTER_RPC_CLIENT_NATS_CONNECT: 'nats://nats:4222'
+      PITAYA_CLUSTER_RPC_CLIENT_NATS_REQUESTTIMEOUT: '10s'
+      PITAYA_CLUSTER_SD_ETCD_ENDPOINTS: 'etcd:2379'
+      PITAYA_CLUSTER_SD_ETCD_PREFIX: 'rubypitaya/'
+      SERVER_ROUTES: 'rubypitaya'
+
+  rubypitaya:
+    depends_on:
+      - 'db'
+      - 'nats'
+      - 'etcd'
+      - 'redis'
+      - 'connector'
+    build:
+      context: '.'
+      dockerfile: 'docker/dev/Dockerfile'
+    working_dir: '/app/rubypitaya'
+    volumes:
+      - '.:/app/rubypitaya'
+      - '/var/run/docker.sock:/var/run/docker.sock'
+    privileged: true
+    environment:
+      SERVER_NAME: 'rubypitaya'
+      RUBYPITAYA_ENV: 'development'
+      HISTFILE: '/app/rubypitaya/.bash-history'
+      NATS_URL: 'nats://nats:4222'
+      ETCD_URL: 'http://etcd:2379'
+      ETCD_PREFIX: 'rubypitaya/'
+      REDIS_URL: 'redis://redis:6379'
+      DATABASE_HOST: 'db'
+      DATABASE_USER: 'postgres'
+      DATABASE_PASSWORD: ''
+      DATABASE_NAME: 'ruby_pitaya'
+
+volumes:
+  postgres:

data/lib/rubypitaya/core/application_files_importer.rb

@@ -0,0 +1,13 @@
+require 'rubypitaya/core/path'
+
+module RubyPitaya
+
+  class ApplicationFilesImporter
+
+    def import
+      app_files_path = "#{Path::APP_FOLDER_PATH}/**/*.rb"
+
+      Gem.find_files(app_files_path).each { |path| require path }
+    end
+  end
+end

data/lib/rubypitaya/core/config.rb

@@ -0,0 +1,33 @@
+module RubyPitaya
+
+  class Config
+
+    def initialize(configs_folder_path)
+      path_to_all_files = File.join(configs_folder_path, '**/*.json')
+      config_files = Dir.glob(path_to_all_files)
+
+      config_hashes = []
+
+      config_files.each do |config_file|
+        config_text = File.open(config_file, &:read)
+        config_readed = JSON.parse(config_text)
+
+        path_array = config_file.sub(/^#{configs_folder_path}/, '')[0..-6]
+                                .split('/')
+        config_hash = path_array.reverse.inject(config_readed) {|a, b| {b => a}}
+
+        config_hashes << config_hash
+      end
+
+      @config = config_hashes.inject(&:deep_merge)
+    end
+
+    def get
+      @config
+    end
+
+    def [](key)
+      @config[key]
+    end
+  end
+end

data/lib/rubypitaya/core/database_config.rb

@@ -0,0 +1,50 @@
+require 'erb'
+require 'yaml'
+
+require 'rubypitaya/core/path'
+
+module RubyPitaya
+
+  class DatabaseConfig
+
+    def initialize(environment_name, database_config_path)
+      @environment_name = environment_name
+
+      yaml_contents = File.open(database_config_path).read
+      @config = YAML.load( ERB.new(yaml_contents).result )
+    end
+
+    def config
+      @config[@environment_name]
+    end
+
+    def connection_data
+      {
+        'adapter': config['adapter'],
+        'encoding': config['encoding'],
+        'pool': config['pool'],
+        'host': config['host'],
+        'user': config['user'],
+        'database': config['database'],
+      }
+    end
+
+    def connection_data_without_database
+      {
+        'adapter': config['adapter'],
+        'encoding': config['encoding'],
+        'pool': config['pool'],
+        'host': config['host'],
+        'user': config['user'],
+      }
+    end
+
+    def database_name
+      config['database']
+    end
+
+    def migrations_path
+      @migrations_path
+    end
+  end
+end

data/lib/rubypitaya/core/database_connector.rb

@@ -0,0 +1,22 @@
+require 'active_record'
+require 'rubypitaya/core/database_config'
+
+module RubyPitaya
+
+  class DatabaseConnector
+
+    def initialize(database_config)
+      @database_config = database_config
+    end
+
+    def connect
+      ActiveRecord::Base.establish_connection(@database_config.connection_data)
+      ActiveRecord::Base.logger = ActiveSupport::Logger.new(STDOUT)
+      ActiveSupport::LogSubscriber.colorize_logging = true
+    end
+
+    def disconnect
+      ActiveRecord::Base.connection.close
+    end
+  end
+end

data/lib/rubypitaya/core/etcd_connector.rb

@@ -0,0 +1,75 @@
+require 'json'
+require 'etcdv3'
+
+module RubyPitaya
+
+  class EtcdConnector
+
+    def initialize(server_uuid, desktop_name, server_name, etcd_prefix,
+                  etcd_address, allow_reconnect)
+      @server_uuid = server_uuid
+      @server_name = server_name
+      @desktop_name = desktop_name
+      @etcd_prefix = etcd_prefix
+      @etcd_address = etcd_address
+      @allow_reconnect = allow_reconnect
+    end
+
+    def connect
+      @connection = Etcdv3.new(endpoints: @etcd_address,
+                              allow_reconnect: @allow_reconnect)
+      @connection.put(connection_key, connection_value)
+    end
+
+    def disconnect
+      @connection.del(connection_key)
+    end
+
+    private
+
+    def connection_key
+      "#{@etcd_prefix}servers/#{@server_name}/#{@server_uuid}"
+    end
+
+    def connection_value
+      JSON.generate(get_server_data)
+    end
+
+    def get_server_data
+      {
+        id: @server_uuid,
+        hostname: @desktop_name,
+        type: @server_name,
+        frontend: false,
+        metadata: {
+          stack: 'default',
+          stackInfo: JSON.generate({
+            Maintenance: false,
+            Platforms: {
+              android: {
+                  Max: '9.9.9',
+                  Min: '0.0.0'
+              },
+              ios: {
+                  Max: '9.9.9',
+                  Min: '0.0.0'
+              },
+              iphoneplayer: {
+                  Max: '9.9.9',
+                  Min: '0.0.0'
+              },
+              mac: {
+                  Max: '9.9.9',
+                  Min: '0.0.0'
+              },
+              osxeditor: {
+                  Max: '9.9.9',
+                  Min: '0.0.0'
+              }
+            }
+          })
+        }
+      }
+    end
+  end
+end

data/lib/rubypitaya/core/handler_base.rb

@@ -0,0 +1,26 @@
+module RubyPitaya
+
+  class HandlerBase
+
+    class_attribute :non_authenticated_routes, default: []
+
+    attr_accessor :bll, :redis, :config, :params, :session, :postman
+
+    def initialize
+      @bll = nil
+      @redis = nil
+      @config = nil
+      @params = nil
+      @session = nil
+      @postman = nil
+    end
+
+    def self.non_authenticated_actions(*action_names)
+      self.non_authenticated_routes = action_names.map(&:to_s)
+    end
+
+    def self.authenticated_action_name?(action_name)
+      !self.non_authenticated_routes.include?(action_name.to_s)
+    end
+  end
+end

data/lib/rubypitaya/core/handler_router.rb

@@ -0,0 +1,71 @@
+require 'rubypitaya/core/handler_base'
+
+module RubyPitaya
+
+  class HandlerRouter
+
+    def initialize(handler_folder_path)
+      import_handler_files(handler_folder_path)
+      import_handler_classes
+    end
+
+    def import_handler_files(handler_folder_path)
+      Gem.find_files("#{handler_folder_path}/*.rb").each { |path| require path }
+    end
+
+    def import_handler_classes
+      handler_classes = ObjectSpace.each_object(HandlerBase.singleton_class).select do |klass|
+        klass != HandlerBase
+      end
+
+      @handlers = handler_classes.map { |handler_class| handler_class.new }
+
+      @handler_name_map = @handlers.map do |handler|
+        handler_name = handler.class.to_s
+        handler_name = handler_name[0].downcase + handler_name[1..-1]
+
+        [handler_name, handler]
+      end
+      @handler_name_map = @handler_name_map.to_h
+    end
+
+    def call(handler_name, action_name, session, postman, redis, config, bll,
+            params)
+      unless @handler_name_map.include?(handler_name)
+        return {
+          code: StatusCodes::CODE_HANDLER_NOT_FOUNDED,
+          msg: "Handler #{handler_name} not founded"
+        }
+      end
+
+      unless @handler_name_map[handler_name].methods.include?(action_name.to_sym)
+        return {
+          code: StatusCodes::CODE_ACTION_NOT_FOUNDED,
+          msg: "Handler #{handler_name} action #{action_name} not founded"
+        }
+      end
+
+      handler = @handler_name_map[handler_name]
+
+      handler.bll = bll
+      handler.redis = redis
+      handler.config = config
+      handler.params = params
+      handler.session = session
+      handler.postman = postman
+
+      if !handler.class.authenticated_action_name?(action_name)
+        handler.send(action_name)
+      else
+        if session.authenticated?
+          handler.send(action_name)
+        else
+          return {
+            code: StatusCodes::CODE_NOT_AUTHENTICATED,
+            msg: 'Not authenticated',
+          }
+        end
+      end
+    end
+  end
+end

data/lib/rubypitaya/core/initializer_base.rb

@@ -0,0 +1,8 @@
+module RubyPitaya
+
+  class InitializerBase
+
+    def run(main)
+    end
+  end
+end

data/lib/rubypitaya/core/initializer_broadcast.rb

@@ -0,0 +1,15 @@
+require 'rubypitaya/core/path'
+require 'rubypitaya/core/initializer_base'
+
+module RubyPitaya
+
+  class InitializerBroadcast
+
+    def run(initializer_content)
+      ObjectSpace.each_object(InitializerBase.singleton_class) do |klass|
+        instance = klass.new
+        instance.run(initializer_content)
+      end
+    end
+  end
+end

data/lib/rubypitaya/core/initializer_content.rb

@@ -0,0 +1,12 @@
+module RubyPitaya
+
+  class InitializerContent
+
+    attr_reader :bll, :redis
+
+    def initialize(bll, redis)
+      @bll = bll
+      @redis = redis
+    end
+  end
+end

data/lib/rubypitaya/core/instance_holder.rb

@@ -0,0 +1,17 @@
+module RubyPitaya
+
+  class InstanceHolder
+
+    def initialize
+      @instances = {}
+    end
+
+    def add_instance(key, instance)
+      @instances[key] = instance
+    end
+
+    def [](key)
+      @instances[key]
+    end
+  end
+end

data/lib/rubypitaya/core/main.rb

@@ -0,0 +1,121 @@
+require 'socket'
+require 'securerandom'
+require 'active_model'
+
+require 'rubypitaya/core/path'
+require 'rubypitaya/core/config'
+require 'rubypitaya/core/session'
+require 'rubypitaya/core/postman'
+require 'rubypitaya/core/parameters'
+require 'rubypitaya/core/handler_router'
+require 'rubypitaya/core/etcd_connector'
+require 'rubypitaya/core/nats_connector'
+require 'rubypitaya/core/database_config'
+require 'rubypitaya/core/redis_connector'
+require 'rubypitaya/core/instance_holder'
+require 'rubypitaya/core/database_connector'
+require 'rubypitaya/core/initializer_content'
+require 'rubypitaya/core/initializer_broadcast'
+require 'rubypitaya/core/application_files_importer'
+
+module RubyPitaya
+
+  class Main
+
+    attr_reader :redis_connector, :config, :bll
+
+    private
+    def initialize
+      @application_files_importer = ApplicationFilesImporter.new
+      @application_files_importer.import
+
+      @server_name = ENV['SERVER_NAME']
+      @service_uuid = SecureRandom.uuid
+      @desktop_name = Socket.gethostname
+
+      @etcd_prefix = ENV['ETCD_PREFIX']
+      @etcd_address = ENV['ETCD_URL']
+      @allow_reconnect = false
+      @etcd_connector = EtcdConnector.new(@service_uuid, @desktop_name,
+                                          @server_name, @etcd_prefix,
+                                          @etcd_address, @allow_reconnect)
+      @etcd_connector.connect
+
+      @nats_address = ENV['NATS_URL']
+      @nats_connector = NatsConnector.new(@nats_address, @service_uuid,
+                                          @server_name)
+
+      @redis_address = ENV['REDIS_URL']
+      @redis_connector = RedisConnector.new(@redis_address)
+      @redis_connector.connect
+
+      @environment_name = ENV.fetch("RUBYPITAYA_ENV") { 'development' }
+      @database_config = DatabaseConfig.new(@environment_name, Path::DATABASE_CONFIG_PATH)
+      @database_connector = DatabaseConnector.new(@database_config)
+      @database_connector.connect
+
+      @session = Session.new
+      @postman = Postman.new(@nats_connector)
+      @config = Config.new(Path::APP_CONFIG_FOLDER_PATH)
+
+      @bll = InstanceHolder.new
+
+      @initializer_content = InitializerContent.new(@bll, @redis_connector.redis)
+      @initializer_broadcast = InitializerBroadcast.new
+      @initializer_broadcast.run(@initializer_content)
+
+      @handler_router = HandlerRouter.new(Path::HANDLERS_FOLDER_PATH)
+
+      puts "Server started!"
+      run_nats_connection
+
+      @etcd_connector.disconnect
+      @database_connector.disconnect
+    end
+
+    def run_nats_connection
+      @nats_connector.connect do |request|
+        start_time_seconds = Time.now.to_i
+
+        message_route = request[:msg][:route]
+        message_data = request[:msg][:data]
+        message_data = JSON.parse(message_data) if message_data.class == String
+
+        params = Parameters.new(message_data)
+
+        session_id = request[:session][:id]
+        session_uid = request[:session].fetch(:uid, '')
+        session_data = request[:session][:data]
+        session_data = JSON.parse(session_data) if session_data.class == String
+        frontend_id = request[:frontendID]
+        metadata = request[:metadata]
+        metadata = JSON.parse(metadata) if metadata.class == String
+
+        @session.update(session_id, session_uid, session_data, metadata,
+                        frontend_id)
+
+        handler_name, action_name = message_route.split('.')[1..-1]
+
+        puts "request  -> route: #{message_route}"
+        puts "         -> data:  #{message_data}"
+
+        response = @handler_router.call(handler_name, action_name, @session,
+                                        @postman, @redis_connector.redis,
+                                        @config, @bll, params)
+
+        delta_time_seconds = Time.now.to_i - start_time_seconds
+
+        puts "response [#{delta_time_seconds}s] -> #{response.to_json}"
+
+        response
+      end
+      rescue SystemExit, Interrupt
+        puts "Quit!"
+        return 0
+      rescue Exception => error
+        puts "ERROR: #{error}"
+        puts error.backtrace
+        run_nats_connection
+    end
+  end
+end

data/lib/rubypitaya/core/nats_connector.rb

@@ -0,0 +1,148 @@
+require 'protobuf'
+require 'nats/client'
+
+module RubyPitaya
+
+  class NatsConnector
+
+    REQUEST_TYPE_SYS  = 0
+    REQUEST_TYPE_USER = 1
+
+    MESSAGE_TYPE_REQUEST  = 0
+    MESSAGE_TYPE_NOTIFY   = 1
+    MESSAGE_TYPE_RESPONSE = 2
+    MESSAGE_TYPE_PUSH     = 3
+
+    def initialize(nats_address, server_uuid, server_name)
+      @server_uuid = server_uuid
+      @server_name = server_name
+      @nats_address = nats_address
+    end
+
+    def connect
+      NATS.start(:servers => [@nats_address]) do |nc|
+
+        NATS.subscribe(subscribe_topic) do |message, reply, a, b|
+          request = NatsRequest.decode(message).to_hash
+
+          Fiber.new do
+            response = yield request
+
+            nats_response = NatsResponse.new(data: response.to_json)
+
+            NATS.publish(reply, nats_response)
+          end.resume
+        end
+
+      end
+    end
+
+    def push_to_frontend(session, message_route, payload)
+      frontend_topic = get_frontend_topic(session.frontend_id)
+
+      nats_message = NatsMessage.new(
+        route: message_route,
+        data: payload,
+        reply: @server_uuid,
+        type: MESSAGE_TYPE_REQUEST,
+      )
+
+      nats_session = NatsSession.new(
+        id: session.id,
+        uid: session.uid,
+        data: session.data.to_json,
+      )
+
+      nats_request = NatsRequest.new(
+        type: REQUEST_TYPE_USER,
+        session: nats_session,
+        msg: nats_message,
+        frontendID: session.frontend_id,
+        metadata: session.metadata.to_json,
+      )
+
+      nats_response = NATS.request(frontend_topic, nats_request)
+      response = NatsResponse.decode(nats_response).to_hash
+
+      response
+    end
+
+    def push_to_user(uid, message_route, payload)
+      user_topic = get_user_message_topic(uid)
+
+      nats_push = NatsPush.new(
+        route: message_route,
+        uid: uid,
+        data: payload.to_json,
+      )
+
+      NATS.publish(user_topic, nats_push)
+
+      0
+    end
+
+    def subscribe_topic
+      "pitaya/servers/#{@server_name}/#{@server_uuid}"
+    end
+
+    def get_frontend_topic(frontend_id)
+      "pitaya/servers/connector/#{frontend_id}"
+    end
+
+    def get_user_message_topic(uid)
+      "pitaya/connector/user/#{uid}/push"
+    end
+  end
+
+  class NatsSession < ::Protobuf::Message; end
+  class NatsMessage < ::Protobuf::Message; end
+  class NatsRequest < ::Protobuf::Message; end
+  class NatsResponse < ::Protobuf::Message; end
+  class NatsError < ::Protobuf::Message; end
+  class NatsBindMsg < ::Protobuf::Message; end
+  class NatsPush < ::Protobuf::Message; end
+
+  class NatsSession
+    optional :int32, :id, 1
+    optional :bytes, :uid, 2
+    optional :bytes, :data, 3
+  end
+
+  class NatsMessage
+    optional :int32, :id, 1
+    optional :bytes, :route, 2
+    optional :bytes, :data, 3
+    optional :bytes, :reply, 4
+    optional :int32, :type,  5
+  end
+
+  class NatsRequest
+    optional :int32, :type, 1
+    optional NatsSession, :session, 2
+    optional NatsMessage, :msg, 3
+    optional :bytes, :frontendID, 4
+    optional :bytes, :metadata, 5
+  end
+
+  class NatsError
+    optional :bytes, :code, 1
+    optional :bytes, :message, 2
+    optional :bytes, :metadata, 3
+  end
+
+  class NatsResponse
+    optional :bytes, :data, 1
+    optional NatsError, :error, 2
+  end
+
+  class NatsBindMsg
+    optional :bytes, :uid, 1
+    optional :bytes, :fid, 2
+  end
+
+  class NatsPush
+    optional :bytes, :route, 1
+    optional :bytes, :uid, 2
+    optional :bytes, :data, 3
+  end
+end