snowman-io 0.0.4 → 0.0.5

data/lib/snowman-io/api/auth_helpers.rb

@@ -0,0 +1,76 @@
+module SnowmanIO
+  module API
+    module AuthHelpers
+      extend ActiveSupport::Concern
+      TOKEN_REGEX = /^Token /
+      AUTHN_PAIR_DELIMITERS = /(?:,|;|\t+)/
+
+      included do
+        helpers do
+          def authenticate!
+            current_user || render_unauthorized
+          end
+
+          def render_unauthorized
+            error! 'Unauthorized', 401, 'WWW-Authenticate' => 'Token realm="Application"'
+          end
+
+          def current_user
+            @current_user ||= authenticate_user_from_token
+          end
+
+          # Code below grabbed from [Ruby on Rails](https://github.com/rails/rails)
+          def authenticate_user_from_token
+            authenticate_with_http_token do |token, options|
+              # # Let use only token for authentication
+              # user_email    = options[:email]
+              # user_email && User.where(email: user_email, authentication_token: token).first
+              User.where(authentication_token: token).first
+            end
+          end
+
+          def authenticate_with_http_token(&login_procedure)
+            token, options = token_and_options
+            unless token.blank?
+              login_procedure.call(token, options)
+            end
+          end
+
+          def token_and_options
+            return if authorization_request.blank?
+
+            if authorization_request.to_s[TOKEN_REGEX]
+              params = token_params_from authorization_request
+              [params.shift.last, Hash[params].with_indifferent_access]
+            end
+          end
+
+          def authorization_request
+            headers["Authorization"]
+          end
+
+          def token_params_from(auth)
+            rewrite_param_values(params_array_from(raw_params(auth)))
+          end
+
+          # Takes raw_params and turns it into an array of parameters
+          def params_array_from(raw_params)
+            raw_params.map { |param| param.split %r/=(.+)?/ }
+          end
+
+          # This removes the `"` characters wrapping the value.
+          def rewrite_param_values(array_params)
+            array_params.each { |param| param.last.gsub! %r/^"|"$/, '' }
+          end
+
+          # pairs by the standardized `:`, `;`, or `\t` delimiters defined in
+          # `AUTHN_PAIR_DELIMITERS`.
+          def raw_params(auth)
+            auth.sub(TOKEN_REGEX, '').split(/"\s*#{AUTHN_PAIR_DELIMITERS}\s*/)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/snowman-io/api/checks.rb

@@ -0,0 +1,59 @@
+module SnowmanIO
+  module API
+    class Checks < Grape::API
+      before(&:authenticate!)
+
+      namespace :checks do
+        params do
+          requires :check, type: Hash do
+            requires :metric_id, type: String
+            requires :cmp, type: String
+            requires :value, type: Float
+            requires :template, type: String
+          end
+        end
+        post do
+          metric = Metric.find(permitted_params[:check][:metric_id])
+          { check: metric.checks.create!(
+            permitted_params[:check].to_h.except("metric_id").merge("user_id" => current_user._id)
+          ) }
+        end
+
+        route_param :id do
+          before do
+            @check = Check.find(params[:id])
+          end
+
+          get do
+            { check: @check }
+          end
+
+          params do
+            requires :check, type: Hash do
+              requires :metric_id, type: String
+              requires :cmp, type: String
+              requires :value, type: Float
+              requires :template, type: String
+            end
+          end
+          put do
+            { check: @check.tap { |m| 
+              m.update_attributes!(permitted_params[:check].to_h.except("metric_id").merge(
+                "triggered" => false,
+                "last_status" => Check::STATUS_NEVER_RUNNED
+              ))
+            } }
+          end
+
+          put 'resolve' do
+            { check: @check.tap { |m| m.update_attributes!(triggered: false) } }
+          end
+
+          delete do
+            Extra::Meteor.model_destroy(Check, @check)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/snowman-io/api/extra/meteor.rb

@@ -0,0 +1,45 @@
+module SnowmanIO
+  module API
+    module Extra
+      # Simple and a little bit ugly web sockets replacement
+      module Meteor
+        def self.all(last)
+          at = Time.at(last)
+          now = Time.now
+
+          if last == 0
+            {
+              users: User.all,
+              apps: App.all,
+              metrics: Metric.all,
+              checks: Check.all,
+              users_deleted: [],
+              apps_deleted: [],
+              metrics_deleted: [],
+              checks_deleted: [],
+              last: now.to_i
+            }
+          else
+            scope = Deleted.where(:created_at.gte => at)
+            {
+              users: User.where(:updated_at.gte => at),
+              apps: App.where(:updated_at.gte => at),
+              metrics: Metric.where(:updated_at.gte => at),
+              checks: Check.where(:updated_at.gte => at),
+              users_deleted: scope.where(model_kind: User.to_s).map(&:model_id),
+              apps_deleted: scope.where(model_kind: App.to_s).map(&:model_id),
+              metrics_deleted: scope.where(model_kind: Metric.to_s).map(&:model_id),
+              checks_deleted: scope.where(model_kind: Check.to_s).map(&:model_id),
+              last: now.to_i
+            }
+          end
+        end
+
+        def self.model_destroy(model, record)
+          Deleted.create!(model_kind: model.to_s, model_id: record.id.to_s)
+          record.destroy
+        end
+      end
+    end
+  end
+end

data/lib/snowman-io/api/fridge.rb

@@ -0,0 +1,14 @@
+module SnowmanIO
+  module API
+    class Fridge < Grape::API
+      before(&:authenticate!)
+
+      params do
+        requires :last, type: Integer
+      end
+      get "fridge" do
+        Extra::Meteor.all(permitted_params[:last])
+      end
+    end
+  end
+end

data/lib/snowman-io/api/info.rb

@@ -0,0 +1,30 @@
+module SnowmanIO
+  module API
+    class Info < Grape::API
+      get "info0" do
+        {
+          unpacked: SnowmanIO.unpacked?
+        }
+      end
+
+      get "info" do
+        authenticate!
+        {
+          base_url: Setting.get(SnowmanIO::BASE_URL_KEY),
+          version: SnowmanIO::VERSION,
+          force_ssl: Setting.force_ssl?,
+          production: (ENV["DEV_MODE"].to_i != 1)
+        }
+      end
+
+      params do
+        requires :force_ssl, type: Boolean
+      end
+      post "force_ssl" do
+        authenticate!
+        Setting.set_force_ssl(permitted_params[:force_ssl])
+        {force_ssl: Setting.force_ssl?}
+      end
+    end
+  end
+end

data/lib/snowman-io/api/metrics.rb

@@ -0,0 +1,115 @@
+module SnowmanIO
+  module API
+    class Metrics < Grape::API
+      before(&:authenticate!)
+
+      namespace :metrics do
+        params do
+          requires :metric, type: Hash do
+            requires :app_id, type: String
+            requires :name, type: String
+            requires :kind, type: String
+            optional :metric_name, type: String
+          end
+        end
+        post do
+          app = App.find(permitted_params[:metric][:app_id])
+          { metric: app.metrics.create!(permitted_params[:metric].to_h.except("app_id")) }
+        end
+
+        route_param :id do
+          before do
+            @metric = Metric.find(params[:id])
+          end
+
+          get do
+            { metric: @metric }
+          end
+
+          params do
+            requires :metric, type: Hash do
+              requires :app_id, type: String
+              requires :name, type: String
+              requires :kind, type: String
+              optional :metric_name, type: String
+            end
+          end
+          put do
+            { metric: @metric.tap { |m| m.update_attributes!(permitted_params[:metric].to_h.except("app_id")) } }
+          end
+
+          delete do
+            Extra::Meteor.model_destroy(Metric, @metric)
+          end
+
+          # Returns data to render chart for metric
+          params do
+            requires :duration, values: ["history", "day", "hour", "5min"]
+          end
+          get "render" do
+            if params[:duration] == "5min"
+              to = Utils.floor_5sec(Time.now)
+              from = to - 5.minutes + 5.seconds
+              delta = 5.seconds
+
+              data = @metric.data_points.where(
+                at: {"$gte" => from, "$lte" => to + delta}
+              ).to_a.group_by { |v| Utils.floor_5sec(v.at).to_i }.map { |k, v| [k, v.count] }.to_h
+
+              datapoints = []
+              at = from
+              while at <= to
+                datapoints.push(at: at, count: data[at.to_i].to_i)
+                at += delta
+              end
+
+              { datapoints: datapoints }
+
+            else
+              if params[:duration] == "history"
+                from = @metric.aggregations.where(precision: "daily").order_by("at" => "asc").first.try(:at)
+                to = @metric.aggregations.where(precision: "daily").order_by("at" => "asc").last.try(:at)
+                precision = "daily"
+                delta = 1.day
+                return { datapoints: [] } unless from && to
+              elsif params[:duration] == "day"
+                to = Time.now.beginning_of_hour
+                from = to - 1.day + 1.hour
+                precision = "hour"
+                delta = 1.hour
+              elsif params[:duration] == "hour"
+                to = Utils.floor_5min(Time.now)
+                from = to - 1.hour + 5.minutes
+                precision = "5min"
+                delta = 5.minutes
+              end
+
+              data = @metric.aggregations.where(
+                precision: precision,
+                at: {"$gte" => from, "$lte" => to + delta}
+              ).to_a.index_by { |v| v.at.to_i }
+
+              datapoints = []
+              at = from
+              while at <= to
+                point = data[at.to_i]
+                datapoints.push(
+                  at: at,
+                  min: data[at.to_i].try(:min).to_f,
+                  avg: data[at.to_i].try(:avg).to_f,
+                  up: data[at.to_i].try(:up).to_f,
+                  max: data[at.to_i].try(:max).to_f,
+                  sum: data[at.to_i].try(:sum).to_f,
+                  count: data[at.to_i].try(:count).to_i
+                )
+                at += delta
+              end
+
+              { datapoints: datapoints }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/snowman-io/api/users.rb

@@ -0,0 +1,231 @@
+module SnowmanIO
+  module API
+    class Users < Grape::API
+      namespace :users do
+        desc "User signup"
+        params do
+          requires :user, type: Hash do
+            requires :name, type: String
+            requires :password, type: String
+            requires :email, type: String
+          end
+        end
+        post do
+          unless SnowmanIO.unpacked?
+            user = User.create!(permitted_params[:user].to_h)
+            { user: user }
+          else
+            status 400
+            { message: "SnowmanIO is unpacked already" }
+          end
+        end
+
+        params do
+          requires :token, type: String
+        end
+        post "check_invite" do
+          {
+            correct: !!(
+              permitted_params[:token].present? &&
+              User.where(status: "wait_invite", invite_token: permitted_params[:token]).first
+            )
+          }
+        end
+
+        params do
+          requires :token, type: String
+          requires :name, type: String
+          requires :password, type: String
+        end
+        post "accept_invite" do
+          if permitted_params[:token].present? && (user = User.where(status: "wait_invite", invite_token: permitted_params[:token]).first)
+            user.update_attributes!(
+              name: permitted_params[:name],
+              password: permitted_params[:password],
+              status: "active",
+              invite_token: ""
+            )
+            { user: user }
+          else
+            status 400
+            { message: "SnowmanIO bad accept_invite request" }
+          end
+        end
+
+        desc "User Signin"
+        params do
+          requires :user, type: Hash do
+            requires :email, type: String
+            optional :password, type: String
+          end
+        end
+        post "login" do
+          email = permitted_params[:user][:email]
+          password = permitted_params[:user][:password]
+          if (user = User.where(email: email).first) && password.present? && user.authenticate(password)
+            { token: user.authentication_token, email: user.email, user_id: user.id.to_s }
+          else
+            status 400
+            { message: "Wrong email or password" }
+          end
+        end
+
+        params do
+          requires :email, type: String
+        end
+        post "restore_password" do
+          if user = User.where(email: permitted_params[:email]).first
+            user.restore_password!
+            {}
+          else
+            status 400
+            { message: "Unknown email" }
+          end
+        end
+
+        params do
+          requires :token, type: String
+          requires :password, type: String
+        end
+        post "reset_password" do
+          if permitted_params[:token].present? && (user = User.where(status: "active", restore_pass_token: permitted_params[:token]).first)
+            user.update_attributes!(
+              password: permitted_params[:password],
+              restore_pass_token: ""
+            )
+            { user: user }
+          else
+            status 400
+            { message: "SnowmanIO bad reset_password request" }
+          end
+        end
+
+        desc "Follow user"
+        post ":id/follow" do
+          authenticate!
+          user = User.find(params[:id])
+          current_user.follow!(user)
+          user.touch
+          current_user.touch
+          { users: [current_user, user] }
+        end
+
+        desc "Unfollow user"
+        post ":id/unfollow" do
+          authenticate!
+          user = User.find(params[:id])
+          current_user.unfollow!(user)
+          user.touch
+          current_user.touch
+          { users: [current_user, user] }
+        end
+
+        post ":id/destroy" do
+          authenticate!
+          user = User.find(params[:id])
+          Extra::Meteor.model_destroy(User, user)
+          { }
+        end
+
+        params do
+          requires :email, type: String
+        end
+        post "invite" do
+          authenticate!
+          if User.where(email: permitted_params[:email]).empty?
+            user = User.create!(
+              email: permitted_params[:email],
+              password: SecureRandom.hex,
+              status: "wait_invite"
+            )
+            user.invite!(current_user)
+            { user: user }
+          else
+            status 400
+            { message: "wrong invite request" }
+          end
+        end
+
+        post ":id/cancel_invite" do
+          authenticate!
+          user = User.where(status: "wait_invite").find(params[:id])
+
+          if user.invite_token.present?
+            user.destroy
+            { }
+          else
+            status 400
+            { message: "wrong invite cancel request" }
+          end
+        end
+
+        post ":id/resend_invite" do
+          authenticate!
+          user = User.where(status: "wait_invite").find(params[:id])
+
+          if user.invite_token.present?
+            user.invite!(current_user)
+            { user: user }
+          else
+            status 400
+            { message: "wrong invite resend request" }
+          end
+        end
+
+        params do
+          requires :value, type: Boolean
+        end
+        post "profile/daily_report" do
+          authenticate!
+          current_user.update_attributes!(daily_report: permitted_params[:value])
+          { user: current_user }
+        end
+
+        params do
+          requires :name, type: String
+        end
+        post "profile/update_name" do
+          authenticate!
+          current_user.update_attributes!(name: permitted_params[:name])
+          { user: current_user }
+        end
+
+        params do
+          requires :email, type: String
+        end
+        post "profile/update_email" do
+          authenticate!
+          new_email = permitted_params[:email]
+          if User.ne(_id: current_user._id).where(email: new_email).empty?
+            current_user.update_attributes!(email: new_email)
+            { user: current_user }
+          else
+            status 400
+            { message: "Duplicate email" }
+          end
+        end
+
+        params do
+          requires :password, type: String
+        end
+        post "profile/update_password" do
+          authenticate!
+          current_user.update_attributes!(password: permitted_params[:password])
+          { }
+        end
+
+        params do
+          requires :token, type: String
+        end
+        post "check_pass_token" do
+          {
+            correct: !!(
+              permitted_params[:token].present? &&
+              User.where(status: "active", restore_pass_token: permitted_params[:token]).first
+            )
+          }
+        end
+      end
+    end
+  end
+end