ssh_scan_api 0.0.1.pre2 → 0.0.1

data/lib/ssh_scan_api/database/mongo.rb

@@ -1,67 +0,0 @@
-require 'mongo'
-
-Mongo::Logger.logger.level = ::Logger::FATAL
-
-module SSHScan
-  module DB
-    class MongoDb
-      attr_reader :collection
-
-      def initialize(client)
-        @client = client
-        @collection = @client[:ssh_scan]
-      end
-
-      # Helps us create a SSHScan::DB::MongoDB object with a hash
-      def self.from_hash(opts)
-        name = opts["name"]
-        server = opts["server"]
-        port = opts["port"]
-        socket = server + ":" + port.to_s
-
-        client = Mongo::Client.new([socket], :database => name)
-        return SSHScan::DB::MongoDb.new(client)
-      end
-
-      # @param [String] worker_id
-      # @param [String] uuid
-      # @param [Hash] result
-       def add_scan(worker_id, uuid, result, socket)
-        @collection.insert_one("uuid" => uuid,
-                          "target" => socket[:target],
-                          "port" => socket[:port],
-                          "scan" => result,
-                          "worker_id" => worker_id)
-      end
-
-      def delete_scan(uuid)
-        @collection.delete_one(:uuid => uuid)
-      end
-
-      def delete_all
-        @collection.delete_many({})
-      end
-
-      # LEFT OFF HERE: the results of this method should be the exact same format as with SQLite
-      def find_scan_result(uuid)
-        @collection.find(:uuid => uuid).each do |doc|
-          return doc[:scan].to_hash
-        end
-        
-        return nil
-      end
-
-      def fetch_cached_result(socket)
-        results = @collection.find(:target => socket[:target], :port => socket[:port])
-        results = results.skip(results.count() - 1)
-        return nil if results.count.zero?
-        result = {}
-        results.each do |result|
-          result[:uuid] = result[:uuid]
-          result[:start_time] = result[:scan][:start_time]
-          return result
-        end
-      end
-    end
-  end
-end

data/lib/ssh_scan_api/database/sqlite.rb

@@ -1,91 +0,0 @@
-require 'sqlite3'
-require 'json'
-
-module SSHScan
-  module DB
-    class SQLite
-      attr_reader :database
-
-      def initialize(database)
-        @database = database # the SQLite database object
-      end
-
-      # Helps us create a SSHScan::DB::SQLite object with a hash
-      def self.from_hash(opts)
-        file_name = opts["file"]
-
-        if File.exist?(file_name)
-          db = ::SQLite3::Database.open(file_name)
-        else
-          db = ::SQLite3::Database.new(file_name)
-        end
-
-        #Check to see if the schema is setup or not
-        result = db.execute <<-SQL
-          SELECT count(*) FROM sqlite_master WHERE type = 'table' AND name = 'ssh_scan';
-        SQL
-
-        # If not, create it
-        if result == [[0]]
-          # Create the schema for the database
-          db.execute <<-SQL
-            create table ssh_scan (
-              uuid varchar(100),
-              target varchar(100),
-              port varchar(100),
-              result json,
-              worker_id varchar(100)
-            );
-          SQL
-        end
-
-        return SSHScan::DB::SQLite.new(db)
-      end
-
-      def size
-        count = @database.execute("select count() from ssh_scan")
-        return count
-      end
-
-      def add_scan(worker_id, uuid, result, socket)
-        @database.execute "insert into ssh_scan values ( ? , ? , ? , ? , ? )",
-                    [uuid, socket[:target], socket[:port],
-                     result.to_json, worker_id]
-      end
-
-      def delete_scan(uuid)
-        @database.execute(
-          "delete from ssh_scan where uuid = ?",
-          uuid
-        )
-      end
-
-      def delete_all
-        @database.execute("delete from ssh_scan")
-      end
-
-      def find_scan_result(uuid)
-        @database.execute(
-          "select * from ssh_scan where uuid like ( ? )",
-          uuid
-        ) do |row|
-          return JSON.parse(row[3])
-        end
-        return nil
-      end
-
-      def fetch_cached_result(socket)
-        result = {}
-        results = @database.execute(
-          "select uuid, result from ssh_scan
-          where target like ( ? ) and port like ( ? )",
-          [socket[:target], socket[:port]]
-        )
-        return nil if results == []
-        result[:uuid] = results[result.length()-1][0]
-        result[:start_time] = JSON.parse(results[result.length()-1][1])["start_time"]
-        return result
-      end
-    end
-  end
-end

data/lib/ssh_scan_api/job_queue.rb

@@ -1,24 +0,0 @@
-module SSHScan
-  class JobQueue
-    def initialize
-      @queue = Queue.new
-    end
-
-    # @param [String] a socket we want to scan (Example: "192.168.1.1:22")
-    # @return [nil]
-    def add(socket)
-      @queue.push(socket)
-    end
-
-    # @return [String] a socket we want to scan (Example: "192.168.1.1:22")
-    def next
-      return nil if @queue.empty?
-      @queue.pop
-    end
-
-    # @return [FixNum] the number of jobs in the JobQueue
-    def size
-      @queue.size
-    end
-  end
-end

data/lib/ssh_scan_api/stats.rb

@@ -1,52 +0,0 @@
-module SSHScan
-  class Stats
-    def initialize
-      @requests = []
-    end
-
-    def new_scan_request
-      @requests << Time.now
-      # Purges the request queue of old requests
-      purge_old_requests
-    end
-
-    def get_stats(queue_size)
-      {
-         :items_queued => queue_size,
-         :avg_requests_per_min => requests_avg_per,
-         :requests_per_min => requests_per
-      }.to_json
-    end
-
-    def size
-      @requests.size
-    end
-
-    # Purges the request queue of old requests, so we don't run the API out of memory
-    # @param [Fixnum] seconds
-    def purge_old_requests(seconds = 60)
-      @requests.delete_if {|request_time| request_time < Time.now - seconds}
-    end
-
-    # Determines the number of requests in a second-based
-    # time period (up to 60 seconds)
-    # @param [Fixnum] seconds
-    # @return [Fixnum] request per time period
-    def requests_per(seconds = 60)
-      requests_per = 0
-      past_time = Time.now - seconds
-
-      @requests.each do |request_time|
-        requests_per += 1 if request_time >= past_time
-      end
-
-      return requests_per
-    end
-
-    # Determines average requests per time period
-    def requests_avg_per(seconds = 60)
-      requests_per = requests_per(seconds)
-      requests_per / seconds.to_f
-    end
-  end
-end