virtuaservices 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 14c9250ccc5f41dec23c9cefe1be32a519667d8df724b037e5be4bee496c0faa
+  data.tar.gz: 4af97b4b7012372092b43c2741525baa7d7164a6d8c6ade9dc0cc1d9bf7f5052
+SHA512:
+  metadata.gz: f735fdb67d12698228fc0c236d3749184012046161d2c71efae1ec3a43c169bb8aaf93c2098be49ec3cc7201ed0270db63c0ae099f74c7e63551fef82ccca489
+  data.tar.gz: 8affa59effed0aca1ad2f2c5df2969c543081afcd21cc2efcfa8613929b87ea3349d1616ff0c2094ebf65551e386c33f7efbf30681f55ae08de43d06604a1557

data/lib/virtuaservices.rb

@@ -0,0 +1,11 @@
+require 'mongoid'
+
+module Virtuaservices
+  autoload :Account       , 'virtuaservices/account'
+  autoload :Authentication, 'virtuaservices/authentication'
+  autoload :Concerns      , 'virtuaservices/concerns'
+  autoload :Monitoring    , 'virtuaservices/monitoring'
+  autoload :OAuth         , 'virtuaservices/oauth'
+  autoload :Permissions   , 'virtuaservices/permissions'
+  autoload :Utils         , 'virtuaservices/utils'
+end

data/lib/virtuaservices/account.rb

@@ -0,0 +1,72 @@
+module Virtuaservices
+  # A user account with all related attributes. It holds credentials and informations about a designated user.
+  # @author Vincent Courtois <courtois.vincent@outlook.com>
+  class Account
+    include Mongoid::Document
+    include Mongoid::Timestamps
+    include ActiveModel::SecurePassword
+    include Virtuaservices::Concerns::Enumerable
+
+    # @!attribute [rw] username
+    #   @return [String] the nickname the user chose at subscription, must be given, unique, and 6 or more characters long.
+    field :username, type: String
+    # @!attribute [r] password_digest
+    #   @return [String] the password of the user, encrypted with the Blowfish algorithm.
+    field :password_digest, type: String
+    # @!attribute [rw] lastname
+    #   @return [String] the last name (family name) of the user.
+    field :lastname, type: String, default: ''
+    # @!attribute [rw] firstname
+    #   @return [String] the first name of the user.
+    field :firstname, type: String, default: ''
+    # @!attribute [rw] email
+    #   @return [String] the email address of the user, useful to contact them ; it must be given, unique, and have an email format.
+    field :email, type: String
+    # @!attribute [rw] language
+    #   @return [Symbol] the language preferred by this user.
+    enum_field :language, [:en_GB, :fr_FR], default: :fr_FR
+    # @!attribute [rw] gender
+    #   @return [Symbol] the way you prefer the application to gender you.
+    enum_field :gender, [:female, :male, :neutral], default: :neutral
+
+    # @!attribute [w] password
+    #   @return [String] password, in clear, of the user ; do not attempt to get the value, just set it when changing the password.
+    # @!attribute [w] password_confirmation
+    #   @return [String] the confirmation of the password, do not get, just set it ; it must be the same as the password.
+    has_secure_password validations: false
+
+    # @!attribute [rw] groups
+    #   @return [Array<Virtuaservices::Permissions::Group>] the groups giving their corresponding rights to the current account.
+    has_and_belongs_to_many :groups, class_name: 'Virtuaservices::Permissions::Group', inverse_of: :accounts
+    
+    # @!attribute [rw] applications
+    #   @return [Array<Virtuaservices::OAuth::Application] the applications this user has created and owns.
+    has_many :applications, class_name: 'Virtuaservices::OAuth::Application', inverse_of: :creator
+    # @!attribute [rw] services
+    #   @return [Array<Virtuaservices::Monitoring::Service>] the services created by this user.
+    has_many :services, class_name: 'Virtuaservices::Monitoring::Service', inverse_of: :creator
+    # @!attribute [rw] sessions
+    #   @return [Array<Virtuaservices::Authentication::Session>] the sessions on which this account is, or has been logged in.
+    has_many :sessions, class_name: 'Virtuaservices::Authentication::Session', inverse_of: :account
+    # @!attribute [rw] websockets
+    #   @return [Array<Virtuaservices::Monitoring::Websocket>] the websockets created by the owner of this account.
+    has_many :websockets, class_name: 'Virtuaservices::Monitoring::Websocket', inverse_of: :creator
+
+    validates :username,
+      presence: {message: 'required'},
+      length: {minimum: 6, message: 'minlength', if: :username?},
+      uniqueness: {message: 'uniq', if: :username?}
+
+    validates :email,
+      presence: {message: 'required'},
+      format: {with: /\A[a-z0-9._%+-]+@[a-z0-9.-]+\.[a-z]{2,}\z/, message: 'pattern', if: :email?},
+      uniqueness: {message: 'uniq', if: :email?}
+
+    validates :password,
+      presence: {message: 'required', if: ->{ !persisted? || password_digest_changed? }},
+      confirmation: {message: 'confirmation', if: :password_digest_changed?}
+
+    validates :password_confirmation,
+      presence: {message: 'required', if: :password_digest_changed?}
+  end
+end

data/lib/virtuaservices/authentication.rb

@@ -0,0 +1,7 @@
+module Virtuaservices
+  # This module holds the logic for user authentication to our frontend.
+  # @author Vincent Courtois <courtois.vincent@outlook.com>
+  module Authentication
+    autoload :Session, 'virtuaservices/authentication/session'
+  end
+end

data/lib/virtuaservices/authentication/session.rb

@@ -0,0 +1,28 @@
+module Virtuaservices
+  module Authentication
+    # A session represents the connection of the user on our frontend application. Nobody else than our frontend should
+    # have access to the session or it's content (in particular to the token), instead they shall use the OAuth2.0 protocol.
+    # A session shall ONLY be created by a premium application (only our frontend applications are premium).
+    # @author Vincent Courtois <courtois.vincent@outlook.com>
+    class Session
+      include Mongoid::Document
+      include Mongoid::Timestamps
+
+      # @!attribute [rw] token
+      #   @return [String] the unique token for this session, used to identify it and be sure the user is connected on this application.
+      field :token, type: String
+      # @!attribute [rw] websocket_id
+      #   @return [String] the ID of the websocket on which the session is connected. It's not an association because instances are embedded.
+      field :websocket_id, type: String, default: ''
+
+      # @!attribute [rw] account
+      #   @return [Virtuaservices::Account] the account connected to the application.
+      belongs_to :account, class_name: 'Virtuaservices::Account', inverse_of: :sessions
+
+      validates :token,
+        presence: {message: 'required'},
+        uniqueness: {message: 'uniq', if: :token?},
+        length: {minimum: 10, message: 'minlength', if: :token?}
+    end
+  end
+end

data/lib/virtuaservices/concerns.rb

@@ -0,0 +1,13 @@
+module Virtuaservices
+  # This module holds the shared concerns to include in the desired models.
+  # @author Vincent Courtois <courtois.vincent@outlook.com>
+  module Concerns
+    autoload :Activable     , 'virtuaservices/concerns/activable'
+    autoload :Diagnosticable, 'virtuaservices/concerns/diagnosticable'
+    autoload :Enumerable    , 'virtuaservices/concerns/enumerable'
+    autoload :MimeTypable   , 'virtuaservices/concerns/mime_typable'
+    autoload :Premiumable   , 'virtuaservices/concerns/premiumable'
+    autoload :Sluggable     , 'virtuaservices/concerns/sluggable'
+    autoload :Typable       , 'virtuaservices/concerns/typable'
+  end
+end

data/lib/virtuaservices/concerns/activable.rb

@@ -0,0 +1,18 @@
+module Virtuaservices
+  module Concerns
+    # Concerns for the objects that can be activated or deactivated, included the corresponding scopes.
+    # @author Vincent Courtois <courtois.vincent@outlook.com>
+    module Activable
+      extend ActiveSupport::Concern
+
+      included do
+        # @!attribute [rw] active
+        #   @return [Boolean] the active status of the instance, indicating if someone has deactivated it or not.
+        field :active, type: Boolean, default: true
+      
+        scope :active  , ->{ where(active: true)  }
+        scope :inactive, ->{ where(active: false) }
+      end
+    end
+  end
+end

data/lib/virtuaservices/concerns/diagnosticable.rb

@@ -0,0 +1,22 @@
+module Virtuaservices
+  module Concerns
+    # Includes the diagnostic URL field, and the related validations.
+    # @author Vincent Courtois <courtois.vincent@outlook.com>
+    module Diagnosticable
+      extend ActiveSupport::Concern
+
+      # Module holding the class methods for the classes including this concern.
+      # @author Vincent Courtois <courtois.vincent@outlook.com>
+      included do
+        # @!attribute [rw] diagnostic
+        #   @return [String] the diagnostic URL to know the status of an entity (usually a gateway, or an instance of a service).
+        field :diagnostic, type: String, default: '/status'
+
+        validates :diagnostic,
+          presence: {message: "required"},
+          length: {minimum: 4, message: "minlength"},
+          format: {with: /\A(\/[a-z]+)+\z/, message: "pattern"}
+      end
+    end
+  end
+end

data/lib/virtuaservices/concerns/enumerable.rb

@@ -0,0 +1,44 @@
+module Virtuaservices
+  module Concerns
+    # Defines enumerations for the Mongoid models. An enumeration is a field that can only use a given set of values.
+    # @author Vincent Courtois <courtois.vincent@outlook.com>
+    module Enumerable
+      extend ActiveSupport::Concern
+
+      # Submodule holding all the static methods add to the current subclass.
+      # @author Vincent Courtois <courtois.vincent@outlook.com>
+      module ClassMethods
+        
+        # Creates the field with the given name, set of possible values, and options.
+        # @param field_name [String] the name of the enumerated field.
+        # @param values [Array<Symbol>] the possible values of the enumerated field.
+        # @param options [Hash<Symbol, Any>] the possible options for the field.
+        def enum_field(field_name, values, options = {})
+          field :"enum_#{field_name}", type: Symbol, default: options[:default]
+
+          validates :"enum_#{field_name}", inclusion: {in: values.map(&:to_sym), message: 'inclusion'}
+
+          define_method field_name do
+            return self["enum_#{field_name}"]
+          end
+
+          define_method "#{field_name}=" do |value|
+            if values.include? value.to_sym
+              self["enum_#{field_name}"] = value.to_sym
+            end
+          end
+
+          values.map(&:to_sym).each do |value|
+            define_method "#{field_name}_#{value}!" do
+              self["enum_#{field_name}"] = value
+            end
+
+            define_method "#{field_name}_#{value}?" do
+              self["enum_#{field_name}"] == value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/virtuaservices/concerns/mime_typable.rb

@@ -0,0 +1,36 @@
+module Virtuaservices
+  module Concerns
+    # Includes the MIME type field to files to ensure only supported types are included.
+    # @author Vincent Courtois <courtois.vincent@outlook.com>
+    module MimeTypable
+      extend ActiveSupport::Concern
+
+      # Submodule holding all the static methods add to the current subclass.
+      # @author Vincent Courtois <courtois.vincent@outlook.com>
+      module ClassMethods
+        # Defines the MIME type attribute with the given possible MIME types.
+        # @param values [Array<String>] the possible MIME types, * can be used as wild cards.
+        def mime_type(values)
+
+          # @!attribute [rw] mime_type
+          #   @return [String] the MIME type of the file, obtained from the uploaded file.
+          field :mime_type, type: String
+      
+          validates :mime_type, presence: {message: 'required'}
+
+          validate :mime_type_validity, if: :mime_type?
+
+          # Validates the validity of the MIME type by checking if it respects any of the given mime types.
+          # If it does not respect any MIME types possible, it adds an error to the mime_type field and invalidates.
+          define_method :mime_type_validity do
+            values.each do |type|
+              type_regex = ::Regexp.new("^#{type.sub(/\*/, '(.+)')}$")
+              return true if !type_regex.match(mime_type).nil?
+            end
+            errors.add(:mime_type, 'pattern')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/virtuaservices/concerns/premiumable.rb

@@ -0,0 +1,15 @@
+module Virtuaservices
+  module Concerns
+    # Includes the premium field to make the entity including it accessible only to premium applications or not.
+    # @author Vincent Courtois <courtois.vincent@outlook.com>
+    module Premiumable
+      extend ActiveSupport::Concern
+
+      included do
+        # @!attribute [rw] premium
+        #   @return [Boolean] TRUE if the entity is made to be accessible only to premiuma pplications, FALSE otherwise.
+        field :premium, type: Boolean, default: false
+      end
+    end
+  end
+end

data/lib/virtuaservices/concerns/sluggable.rb

@@ -0,0 +1,27 @@
+module Virtuaservices
+  module Concerns
+    # Includes the slug field, always the same in all models.
+    # @author Vincent Courtois <courtois.vincent@outlook.com>
+    module Sluggable
+      extend ActiveSupport::Concern
+
+      # Module holding the class methods for the classes including this concern.
+      # @author Vincent Courtois <courtois.vincent@outlook.com>
+      module ClassMethods
+        # Add the field and its validations in the model including it.
+        # @param entity_type [String,Symbol] the name of the model including it, to be included in the error messages.
+        def make_sluggable(entity_type)
+          # @!attribute [rw] slug
+          #   @return [String] the slug of the current entity ; it must be snake-cased, longer than four characters, unique for the entity and given.
+          field :slug, type: String
+
+          validates :slug,
+            length: {minimum: 4, message: 'minlength', if: :slug?},
+            format: {with: /\A[a-z]+(_[a-z]+)*\z/, message: 'pattern', if: :slug?},
+            uniqueness: {message: 'uniq', if: :slug?},
+            presence: {message: 'required'}
+        end
+      end
+    end
+  end
+end

data/lib/virtuaservices/concerns/typable.rb

@@ -0,0 +1,17 @@
+module Virtuaservices
+  module Concerns
+    # Concerns for the objects that can be activated or deactivated, included the corresponding scopes.
+    # @author Vincent Courtois <courtois.vincent@outlook.com>
+    module Typable
+      extend ActiveSupport::Concern
+
+      included do
+        include Virtuaservices::Concerns::Enumerable
+        
+        # @!attribute [rw] type
+        #   @return [Symbol] the type of the instance, determining its way of being deployed, restarted, etc.
+        enum_field :type, [:heroku, :local, :unix], default: :heroku
+      end
+    end
+  end
+end

data/lib/virtuaservices/monitoring.rb

@@ -0,0 +1,12 @@
+module Virtuaservices
+  # The monitoring module holds all the logic about the services so they can be activated or deactivated.
+  # @author Vincent Courtois <courtois.vincent@outlook.com>
+  module Monitoring
+    autoload :Action   , 'virtuaservices/monitoring/action'
+    autoload :Gateway  , 'virtuaservices/monitoring/gateway'
+    autoload :Instance , 'virtuaservices/monitoring/instance'
+    autoload :Route    , 'virtuaservices/monitoring/route'
+    autoload :Service  , 'virtuaservices/monitoring/service'
+    autoload :Websocket, 'virtuaservices/monitoring/websocket'
+  end
+end

data/lib/virtuaservices/monitoring/action.rb

@@ -0,0 +1,25 @@
+module Virtuaservices
+  module Monitoring
+    # An action is made by an authorized user on the instance of a server to perform a task.
+    # @author Vincent Courtois <courtois.vincent@outlook.com>
+    class Action
+      include Mongoid::Document
+      include Mongoid::Timestamps
+      include Virtuaservices::Concerns::Enumerable
+
+      # @!attribute [rw] type
+      #   @return [Symbol] the type of action you're making on this instance
+      enum_field :type, [:restart]
+      # @!attribute [rw] success
+      #   @return [Boolean] TRUE if the action succeeded (or at least was successfully launched), FALSE otherwise.
+      field :success, type: Boolean, default: false
+
+      # @!attribute [rw] user
+      #   @return [Virtuaservices::Account] the user performing the action on the instance.
+      belongs_to :user, class_name: 'Virtuaservices::Account'
+      # @!attribute [rw] instance
+      #   @return [Virtuaservices::Monitoring::Instance] the instance of a service on which the action is performed.
+      embedded_in :instance, class_name: 'Virtuaservices::Monitoring::Instance', inverse_of: :actions
+    end
+  end
+end

data/lib/virtuaservices/monitoring/gateway.rb

@@ -0,0 +1,37 @@
+module Virtuaservices
+  module Monitoring
+    # A gateway is a portal by which you access the different web services of the application suite.
+    # @author Vincent Courtois <courtois.vincent@outlook.com>
+    class Gateway
+      include Mongoid::Document
+      include Mongoid::Timestamps
+      include Virtuaservices::Concerns::Activable
+      include Virtuaservices::Concerns::Diagnosticable
+      include Virtuaservices::Concerns::Typable
+
+      # @!attribute [rw] url
+      #   @return [String] the URL of the gateway, where the requests will be issued.
+      field :url, type: String
+      # @!attribute [rw] running
+      #   @return [Boolean] the running status of the gateway, indicating if it can be used or not.
+      field :running, type: Boolean, default: false
+      # @!attribute [rw] gateways
+      #   @return [String] the uniq token for this gateway, identifying it in the micro services.
+      field :token, type: String
+
+      scope :running , ->{ where(running: true) }
+
+      validates :url,
+        presence: {message: 'required'},
+        format: {
+          with: /\A(https?:\/\/)((localhost:[0-9]+)|(([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-]*)*)|(\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b):([0-9]{2,6}))\/?\z/,
+          message: 'pattern',
+          if: :url?
+        }
+
+      validates :token,
+        presence: {message: 'required'},
+        uniqueness: {message: 'uniq'}
+    end
+  end
+end

data/lib/virtuaservices/monitoring/instance.rb

@@ -0,0 +1,36 @@
+module Virtuaservices
+  module Monitoring
+    # An instance is one of the services, deployed on one server. A service may have many instances to balance the load between them all.
+    # @author Vincent Courtois <courtois.vincent@outlook.com>
+    class Instance
+      include Mongoid::Document
+      include Mongoid::Timestamps
+      include Virtuaservices::Concerns::Activable
+      include Virtuaservices::Concerns::Typable
+
+      # @!attribute [rw] url
+      #   @return [String] the URL of the instance, where the requests will be issued.
+      field :url, type: String
+      # @!attribute [rw] running
+      #   @return [Boolean] the running status of the instance, indicating if it can be used or not.
+      field :running, type: Boolean, default: false
+      # @!attribute [rw] data
+      #   @return [Hash] the additional datas for this instance (for example for an Heroku instance it's all the data provided by the API)
+      field :data, type: Hash, default: {}
+
+      scope :running , ->{ where(running: true) }
+
+      # @!attribute [r] service
+      #   @return [Virtuaservices::Monitoring::Service] the service this instance is linked to.
+      embedded_in :service, class_name: 'Virtuaservices::Monitoring::Service', inverse_of: :instances
+      # @!attribute [rw] actions
+      #   @return [Virtuaservices::Monitoring::Action] the actions that has been performed on the service.
+      embeds_many :actions, class_name: 'Virtuaservices::Monitoring::Action', inverse_of: :instance
+
+      validates :url,
+        presence: {message: 'required'},
+        format: {with: /\A(https?:\/\/)((([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-]*)*)|(localhost:[0-9]{2,4})\/?)\z/, message: 'pattern', if: :url?}
+    end
+  end
+end
+