wrata_api 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 557d84f0f762d728293064900d541e64bbac2f72cee30cbbc7453255f7f1dcc3
+  data.tar.gz: ab8a8885d4fe45746712d1614c9fc0b35676934eee88b9583fbe5550fbf48ddf
+SHA512:
+  metadata.gz: 73a54b8332386382265bc660375cdeccb022a56d7cbc1b0898aa3447e11b792ad7e811ccb0b16cf4644a2eb690af56648b032e63b70d4e36a6c7b39b1f963dd0
+  data.tar.gz: 254b4c171a0d637a1c1ffc1d5013d98127212f4c6ff6fe727afaf94fd79687d692928682338330c573516e5d264ee54c08ef376296e2f16cd48d505ceffbc33a

data/lib/wrata_api.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative 'wrata_api/wrata_api_request'
+require_relative 'wrata_api/server_list'
+require_relative 'wrata_api/server_methods'
+require_relative 'wrata_api/file_tree'
+require_relative 'wrata_api/queue_methos'
+require 'json'
+require 'logger'
+require 'uri'
+require 'yaml'
+# Mail module of gem
+module WrataApi
+  # Class for working with wrata api
+  class WrataApi
+    include WrataApiRequest
+    include ServerMethods
+    include FileListMethods
+    include QueueMethods
+
+    def initialize(config = nil)
+      config ||= YAML.load_file("#{ENV['HOME']}/.gem-wrata/config.yaml")
+      @uri = config['uri']
+      @cookie = config['cookie']
+      @wrata_session = config['wrata_session']
+      @csrf_token = config['csrf_token']
+      @logger = Logger.new(STDOUT)
+      @waiting_timeout = 5 * 60
+      @between_request_timeout = 10
+    end
+
+    # @return [True, False] check if service is running
+    def available?
+      uri = URI("#{@uri}/signin")
+      begin
+        source = Net::HTTP.get(uri)
+      rescue StandardError
+        source = ''
+      end
+      available = source.include?('Runner')
+      @logger.info("wrata_available?(#{@uri}): #{available}")
+      available
+    end
+  end
+end

data/lib/wrata_api/file_tree.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module WrataApi
+  # Methods to work with file tree
+  module FileListMethods
+    def file_list(project, ref = 'master')
+      uri = URI.parse("#{@uri}/runner/file_tree")
+      body = {
+        'flatten' => true,
+        'project' => project,
+        'refs' => ref
+      }
+      perform_get(uri, body)
+    end
+  end
+end

data/lib/wrata_api/name.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module WrataApi
+  # This module holds the WrataApi version information.
+  module Name
+    # @return [String] current gem version
+    STRING = 'wrata_api'
+  end
+end

data/lib/wrata_api/queue_methos.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module WrataApi
+  # Methods for working with queue
+  module QueueMethods
+    # Clear test in queue
+    # @return [Nothing]
+    def clear_tests_list
+      uri = URI.parse("#{@uri}/queue/clear_tests")
+      perform_post(uri)
+    end
+
+    # Get list of tests in queue
+    # @return [Array<Hash>] test list data
+    def tests_in_queue
+      uri = URI.parse("#{@uri}/runner/updated_data")
+      response = perform_get(uri)
+      response['queue_data']['tests']
+    end
+
+    # Add test to queue
+    # @param tests_to_add [String] path to add test
+    # @param options [Hash] string of some options
+    # @return [Nothing]
+    def add_to_queue(tests_to_add, options = {})
+      uri = URI.parse("#{@uri}/queue/add_test")
+
+      options = queue_item_default_values(options)
+      body = {
+        'test_path' => tests_to_add,
+        'branch' => options[:branch],
+        'location' => options[:location],
+        'spec_browser' => options[:browser]
+      }
+      perform_post(uri, body)
+    end
+
+    # Add default value to queue item
+    # @param options [Hash] values for add to queue
+    # @return [Hash] after adding default
+    def queue_item_default_values(options)
+      options[:branch] ||= 'develop'
+      options[:location] ||= 'info us'
+      options[:browser] ||= 'default'
+      options
+    end
+
+    # Add several tests to queue
+    # @param test_list [Array, String] tests to add
+    # @param options [Hash] option to each test
+    # @return [Nothing]
+    def add_tests_to_queue(test_list, options = {})
+      test_list.each do |current_test|
+        add_to_queue(current_test, options)
+      end
+    end
+  end
+end

data/lib/wrata_api/server_list.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module WrataApi
+  # Class for working with several servers at once
+  class ServerList
+    # @return [Array, Hash] list of servers
+    attr_accessor :servers
+
+    def initialize(api)
+      @api = api
+      @servers = []
+      @concurrent_operation_at_once = 5
+    end
+
+    # @return [Integer] count of servers
+    def length
+      @servers.length
+    end
+
+    # Turn on all servers in list
+    def concurrent_action
+      splitted_servers = @servers.each_slice(@concurrent_operation_at_once).to_a
+      splitted_servers.each do |each_slice|
+        threads = []
+        each_slice.each do |current_server|
+          threads << Thread.new(current_server) do
+            yield(current_server)
+          end
+        end
+        threads.each(&:join)
+      end
+    end
+
+    # Power on all servers
+    # @return [Nothing]
+    def power_on(size = nil)
+      concurrent_action do |server|
+        @api.power_on_server(server['name'], size)
+      end
+    end
+
+    # @return [True, False] is all servers powered on?
+    def powered_on?
+      @servers.each do |current|
+        return false unless @api.powering_status(current['name']) == :on
+      end
+      true
+    end
+
+    # Power on all servers
+    # @return [Nothing]
+    def power_off
+      concurrent_action do |server|
+        @api.power_off_server(server['name'])
+      end
+    end
+
+    # @return [True, False] is all servers powered on?
+    def powered_off?
+      @servers.each do |current|
+        return false unless @api.powering_status(current['name']) == :off
+      end
+      true
+    end
+
+    # Book each server
+    # @return [Nothing]
+    def book
+      @servers.each do |current|
+        @api.book_server(current['name'])
+      end
+    end
+
+    # Unbook each server
+    # @return [Nothing]
+    def unbook
+      @servers.each do |current|
+        @api.unbook_server(current['name'])
+      end
+    end
+  end
+end

data/lib/wrata_api/server_methods.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require_relative 'server_methods/server_methods_exceptions'
+module WrataApi
+  # Methods for getting server status
+  module ServerMethods
+    # @return [Array, String] list of all servers
+    def servers
+      uri = URI.parse("#{@uri}/servers.json")
+      perform_get(uri)
+    end
+
+    # Got as much free servers as `count`
+    # @param count [Integer] how much servers to got
+    # @return [Array, Hash]
+    def free_servers(count)
+      free = ServerList.new(self)
+      raise NotEnoughServerCount if count > servers.length
+
+      servers.each do |single_server|
+        free.servers << single_server if single_server['book_client_id'].nil?
+        return free if free.length == count
+      end
+    end
+
+    # @return [Hash] Return servers data
+    def server_data(server_name)
+      uri = URI.parse("#{@uri}/runner/updated_data")
+      response = perform_get(uri, 'servers' => [{ name: server_name }].to_json)
+      response['servers_data'].first
+    end
+
+    # @return [Symbol] if server is powered on or off
+    def powering_status(server_name)
+      all_data = server_data(server_name)
+      status = all_data['_status']
+      if status == 'created'
+        :on
+      elsif status == 'destroyed'
+        :off
+      else
+        :other
+      end
+    end
+
+    # @return [True, False] check if server execute some test
+    def executing_test?(server_name)
+      all_data = server_data(server_name)
+      all_data.key?('test')
+    end
+
+    # @param server_name [Server] server to unbook
+    # @return [Nothing]
+    def unbook_server(server_name)
+      uri = URI.parse("#{@uri}/queue/unbook_server")
+      perform_post(uri, 'server' => server_name)
+    end
+
+    # @param server_name [Server] server to book
+    # @return [Nothing]
+    def book_server(server_name)
+      uri = URI.parse("#{@uri}/queue/book_server")
+      perform_post(uri, 'server' => server_name)
+    end
+
+    # @param server_name [Server] server to power on
+    # @return [Nothing]
+    def power_on_server(server_name, size = nil)
+      return if powering_status(server_name) == :on
+
+      uri = URI.parse("#{@uri}/servers/cloud_server_create")
+      perform_post(uri, 'server' => server_name, 'size' => size)
+      wait_for_server_have_status(server_name, :on)
+    end
+
+    # @param server_name [Server] server to power on
+    # @return [Nothing]
+    def power_off_server(server_name)
+      return if powering_status(server_name) == :off
+
+      unbook_server(server_name)
+      uri = URI.parse("#{@uri}/servers/cloud_server_destroy")
+      perform_post(uri, 'server' => server_name)
+      wait_for_server_have_status(server_name, :off)
+    end
+
+    # Waiting until server have statue
+    # @param server [String] name of server
+    # @param status [Symbol] state to wait
+    # @return [Nothing]
+    def wait_for_server_have_status(server, status)
+      current_wait_time = 0
+      loop do
+        return if powering_status(server) == status
+
+        @logger.info("Wait for state: #{status}: \
+                      #{current_wait_time} of: #{@waiting_timeout}")
+        sleep @between_request_timeout
+        current_wait_time += @between_request_timeout
+        raise(server_status_timeout_error(server, status)) if current_wait_time > @waiting_timeout
+      end
+    end
+
+    # @param server [String] name of server
+    # @param status [String] status to wait failed
+    # @return [String] error for server timeout
+    def server_status_timeout_error(server, status)
+      "Couldn't wait until #{server} have status "\
+      "#{status} in specified timeout"
+    end
+  end
+end

data/lib/wrata_api/server_methods/server_methods_exceptions.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module WrataApi
+  # Class raised if server count is too big
+  class NotEnoughServerCount < StandardError
+  end
+end

data/lib/wrata_api/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module WrataApi
+  # This module holds the WrataApi version information.
+  module Version
+    # @return [String] current gem version
+    STRING = '0.1.0'
+  end
+end

data/lib/wrata_api/wrata_api_request.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'net/http'
+module WrataApi
+  # Module for describing base request actions
+  module WrataApiRequest
+    # @return [Hash] default header for requests
+    def default_header
+      { 'Cookie' => "remember_token=#{@cookie}; \
+                    _runner_session=#{@wrata_session}",
+        'X-CSRF-Token' => @csrf_token }
+    end
+
+    # Make get request
+    # @param uri [URI] uri wiht server
+    # @param body [Hash] body of request
+    # @return [JSON] result of request
+    def perform_get(uri, body = {})
+      http = Net::HTTP.new(uri.host, uri.port)
+      request = Net::HTTP::Get.new(uri.request_uri, default_header)
+      request.set_form_data(body)
+      body = http.request(request).body
+      @logger.info("Get request: #{uri} answered: #{body}")
+      return {} if body.empty?
+
+      JSON.parse(body)
+    end
+
+    # Make post request
+    # @param uri [URI] uri wiht server
+    # @param body [Hash] body of request
+    # @return [JSON] result of request
+    def perform_post(uri, body = {})
+      http = Net::HTTP.new(uri.host, uri.port)
+      request = Net::HTTP::Post.new(uri.request_uri, default_header)
+      request.set_form_data(body)
+      http.read_timeout = 500
+      body = http.request(request).body
+      @logger.info("Post request: #{uri} answered: #{body}")
+      return {} if body.empty?
+
+      JSON.parse(body)
+    end
+  end
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: wrata_api
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- ONLYOFFICE
+- Pavel Lobashov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-05-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: Wrapper around wrata API
+email:
+- shockwavenn@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/wrata_api.rb
+- lib/wrata_api/file_tree.rb
+- lib/wrata_api/name.rb
+- lib/wrata_api/queue_methos.rb
+- lib/wrata_api/server_list.rb
+- lib/wrata_api/server_methods.rb
+- lib/wrata_api/server_methods/server_methods_exceptions.rb
+- lib/wrata_api/version.rb
+- lib/wrata_api/wrata_api_request.rb
+homepage: https://github.com/ONLYOFFICE/wrata_api
+licenses:
+- AGPL-3.0
+metadata:
+  bug_tracker_uri: https://github.com/ONLYOFFICE/wrata_api/issues
+  changelog_uri: https://github.com/ONLYOFFICE/wrata_api/blob/master/CHANGELOG.md
+  documentation_uri: https://www.rubydoc.info/gems/wrata_api
+  homepage_uri: https://github.com/ONLYOFFICE/wrata_api
+  source_code_uri: https://github.com/ONLYOFFICE/wrata_api
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Wrata API Gem
+test_files: []