qtc-sdk 0.0.1

data/lib/qtc/cli/mar/domains.rb

@@ -0,0 +1,38 @@
+require_relative 'base'
+
+module Qtc
+  module Cli
+    class Mar::Domains < Mar::Base
+
+      def list(options)
+        instance_id = resolve_instance_id(options)
+        instance_data = instance_info(instance_id)
+        if instance_data
+          token = instance_data['authorizations'][0]['access_token']
+          result = client.get("/apps/#{instance_id}/domains", nil, {'Authorization' => "Bearer #{token}"})
+          result['results'].each do |r|
+            print color("* #{r['name']}", :bold)
+          end
+        end
+      end
+
+      def create(name, options)
+        instance_id = resolve_instance_id(options)
+        instance_data = instance_info(instance_id)
+        if instance_data
+          token = instance_data['authorizations'][0]['access_token']
+          client.post("/apps/#{instance_id}/domains", {name: name}, {}, {'Authorization' => "Bearer #{token}"})
+        end
+      end
+
+      def destroy(name, options)
+        instance_id = resolve_instance_id(options)
+        instance_data = instance_info(instance_id)
+        if instance_data
+          token = instance_data['authorizations'][0]['access_token']
+          client.delete("/apps/#{instance_id}/domains/#{name}", nil, nil, {'Authorization' => "Bearer #{token}"})
+        end
+      end
+    end
+  end
+end

data/lib/qtc/cli/mar/env.rb

@@ -0,0 +1,40 @@
+require_relative 'base'
+
+module Qtc
+  module Cli
+    class Mar::Env < Mar::Base
+
+      def set(vars, options)
+        instance_id = resolve_instance_id(options)
+        env_vars = {}
+        vars.each do |type|
+          arr = type.strip.split("=")
+          if arr[0]
+            if arr[1].nil? || arr[1] == ""
+              env_vars[arr[0]] = nil
+            else
+              env_vars[arr[0]] = arr[1..-1].join("=")
+            end
+          end
+        end
+        instance_data = instance_info(instance_id)
+        if instance_data
+          token = instance_data['authorizations'][0]['access_token']
+          client.put("/apps/#{instance_id}/env_vars", env_vars, {}, {'Authorization' => "Bearer #{token}"})
+        end
+      end
+
+      def show(options)
+        instance_id = resolve_instance_id(options)
+        instance_data = instance_info(instance_id)
+        if instance_data
+          token = instance_data['authorizations'][0]['access_token']
+          env_vars = client.get("/apps/#{instance_id}/env_vars", {}, {'Authorization' => "Bearer #{token}"})
+          env_vars.each do |key, value|
+            puts "#{key}=#{value}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/qtc/cli/mar/ssl_certificates.rb

@@ -0,0 +1,36 @@
+require 'base64'
+require_relative 'base'
+
+module Qtc
+  module Cli
+    class Mar::SslCertificates < Mar::Base
+
+
+      def create(options)
+        raise ArgumentError.new("--key=#{opts.key} is not a file") unless File.exists(opts.key)
+        raise ArgumentError.new("--cert=#{opts.cert} is not a file") unless File.exists(opts.cert)
+
+        instance_id = resolve_instance_id(options)
+        instance_data = instance_info(instance_id)
+        if instance_data
+          token = instance_data['authorizations'][0]['access_token']
+          data = {
+            name: instance_id,
+            privateKey: File.read(opts.key),
+            certificateBody: File.read(opts.cert)
+          }
+          client.post("/apps/#{instance_id}/ssl_certificate", data, {}, {'Authorization' => "Bearer #{token}"})
+        end
+      end
+
+      def destroy(options)
+        instance_id = resolve_instance_id(options)
+        instance_data = instance_info(instance_id)
+        if instance_data
+          token = instance_data['authorizations'][0]['access_token']
+          client.delete("/apps/#{instance_id}/ssl_certificate", {}, {}, {'Authorization' => "Bearer #{token}"})
+        end
+      end
+    end
+  end
+end

data/lib/qtc/client.rb

@@ -0,0 +1,170 @@
+require 'json'
+require 'httpclient'
+require_relative 'errors'
+
+module Qtc
+  class Client
+
+    attr_accessor :default_headers
+    attr_reader :http_client
+
+    # Initialize api client
+    #
+    # @param [String] api_url
+    # @param [Hash] default_headers
+    def initialize(api_url, default_headers = {})
+      @http_client = HTTPClient.new
+      @default_headers = {'Accept' => 'application/json', 'Content-Type' => 'application/json'}.merge(default_headers)
+      @api_url = api_url
+    end
+
+    # Get request
+    #
+    # @param [String] path
+    # @param [Hash,NilClass] params
+    # @return [Hash]
+    def get(path, params = nil, headers = {})
+      response = http_client.get(request_uri(path), params, request_headers(headers))
+      if response.status == 200
+        parse_response(response)
+      else
+        handle_error_response(response)
+      end
+    end
+
+    # Post request
+    #
+    # @param [String] path
+    # @param [Object] obj
+    # @param [Hash] params
+    # @param [Hash] headers
+    # @return [Hash]
+    def post(path, obj, params = {}, headers = {})
+      request_headers = request_headers(headers)
+      request_options = {
+          header: request_headers,
+          body: encode_body(obj, request_headers['Content-Type']),
+          query: params
+      }
+      response = http_client.post(request_uri(path), request_options)
+      if [200, 201].include?(response.status)
+        parse_response(response)
+      else
+        handle_error_response(response)
+      end
+    end
+
+    # Put request
+    #
+    # @param [String] path
+    # @param [Object] obj
+    # @param [Hash] params
+    # @param [Hash] headers
+    # @return [Hash]
+    def put(path, obj, params = {}, headers = {})
+      request_headers = request_headers(headers)
+      request_options = {
+          header: request_headers,
+          body: encode_body(obj, request_headers['Content-Type']),
+          query: params
+      }
+
+      response = http_client.put(request_uri(path), request_options)
+      if [200, 201].include?(response.status)
+        parse_response(response)
+      else
+        handle_error_response(response)
+      end
+    end
+
+    # Delete request
+    #
+    # @param [String] path
+    # @param [Hash,String] body
+    # @param [Hash] params
+    # @param [Hash] headers
+    # @return [Hash]
+    def delete(path, body = nil, params = {}, headers = {})
+      request_headers = request_headers(headers)
+      request_options = {
+          header: request_headers,
+          body: encode_body(body, request_headers['Content-Type']),
+          query: params
+      }
+      response = http_client.delete(request_uri(path), request_options)
+      if response.status == 200
+        parse_response(response)
+      else
+        handle_error_response(response)
+      end
+    end
+
+    private
+
+    ##
+    # Get full request uri
+    #
+    # @param [String] path
+    # @return [String]
+    def request_uri(path)
+      "#{@api_url}#{path}"
+    end
+
+    ##
+    # Get request headers
+    #
+    # @param [Hash] headers
+    # @return [Hash]
+    def request_headers(headers = {})
+      @default_headers.merge(headers)
+    end
+
+    ##
+    # Encode body based on content type
+    #
+    # @param [Object] body
+    # @param [String] content_type
+    def encode_body(body, content_type)
+      if content_type == 'application/json'
+        dump_json(body)
+      else
+        body
+      end
+    end
+
+    ##
+    # Parse response
+    #
+    # @param [HTTP::Message]
+    # @return [Object]
+    def parse_response(response)
+      if response.headers['Content-Type'].include?('application/json')
+        parse_json(response.body)
+      else
+        response.body
+      end
+    end
+
+    ##
+    # Parse json
+    #
+    # @param [String] json
+    # @return [Hash,Object,NilClass]
+    def parse_json(json)
+      JSON.parse(json) rescue nil
+    end
+
+    ##
+    # Dump json
+    #
+    # @param [Object] obj
+    # @return [String]
+    def dump_json(obj)
+      JSON.dump(obj)
+    end
+
+    def handle_error_response(response)
+      raise Qtc::Errors::StandardError.new(response.status, response.body)
+    end
+  end
+end

data/lib/qtc/eds/client.rb

@@ -0,0 +1,117 @@
+require_relative 'collection'
+require_relative 'user_collection'
+require_relative 'usergroup_collection'
+
+module Qtc
+  module Eds
+    class Client
+
+      DEFAULT_OPTIONS = {
+          api_url: 'https://api.engin.io/v1'
+      }
+
+      ##
+      # Initialize
+      #
+      # @param [String] backend_id
+      # @param [Hash] options
+      def initialize(backend_id, options = {})
+        @options = DEFAULT_OPTIONS.merge(options)
+        @backend_id = backend_id
+        headers = {'Enginio-Backend-Id' => @backend_id}
+        @client = Qtc::Client.new(@options[:api_url], headers)
+      end
+
+      ##
+      # Get Qtc::Client instance
+      #
+      # @return [Qtc::Client]
+      def http_client
+        @client
+      end
+
+      ##
+      # Get collection
+      #
+      # @param [String] name
+      # @return [Qtc::Eds::Collection]
+      def collection(name)
+        Qtc::Eds::Collection.new(@client, "/objects/#{name}")
+      end
+
+      ##
+      # Get user collection
+      #
+      # @return [Qtc::Eds::UserCollection]
+      def users
+        Qtc::Eds::UserCollection.new(@client)
+      end
+
+      ##
+      # Get usergroup collection
+      #
+      # @return [Qtc::Eds::UsergroupCollection]
+      def usergroups
+        Qtc::Eds::UsergroupCollection.new(@client)
+      end
+
+      def current_user
+        if @client.default_headers['Authorization']
+          @client.get('/user')
+        end
+      end
+
+      ##
+      # Set access token
+      #
+      # @param [String] access_token
+      def access_token=(access_token)
+        if !access_token.nil?
+          @client.default_headers['Authorization'] = "Bearer #{access_token}"
+        else
+          @client.default_headers.delete('Authorization')
+        end
+      end
+
+      ##
+      # Call block with given access token
+      #
+      # @param [String] access_token
+      # @param []
+      def with_access_token(access_token, &block)
+        prev_auth = @client.default_headers['Authorization'].dup
+        @client.default_headers['Authorization'] = "Bearer #{access_token}"
+        result = call(&block)
+        @client.default_headers['Authorization'] = prev_auth
+        result
+      ensure
+        @client.default_headers['Authorization'] = prev_auth if prev_auth
+      end
+
+      ##
+      # Create user access token
+      #
+      # @param [String] username
+      # @param [String] password
+      def create_user_token(username, password)
+        body = {
+            grant_type: 'password',
+            username: username,
+            password: password
+        }
+        @client.post('/auth/oauth2/token', body, {}, {'Content-Type' => 'application/x-www-form-urlencoded'})
+      end
+
+      ##
+      # Revoke user access token
+      #
+      # @param [String] token
+      def revoke_user_token(token)
+        body = {
+            token: token
+        }
+        @client.post('/auth/oauth2/revoke', body, {}, {'Content-Type' => 'application/x-www-form-urlencoded'})
+      end
+    end
+  end
+end

data/lib/qtc/eds/collection.rb

@@ -0,0 +1,125 @@
+module Qtc
+  module Eds
+    class Collection
+
+      ##
+      # Initialize EDS collection
+      #
+      # @param [Qtc::Client] client
+      # @param [String] path
+      def initialize(client, path)
+        @client = client
+        @path = path
+      end
+
+      ##
+      # Insert a new object
+      #
+      # @param [Hash] object
+      # @return [Hash]
+      def insert(object)
+        client.post(path, object)
+      end
+
+      ##
+      # Update object
+      #
+      # @param [String] id
+      # @param [Hash] object
+      # @return [Hash]
+      def update(id, object)
+        client.put("#{path}/#{id}", object)
+      end
+
+      ##
+      # Atomic operation
+      #
+      # @param [String] id
+      # @param [Hash] operation
+      # @return [Hash]
+      def atomic_operation(id, operation)
+        client.put("#{path}/#{id}/atomic", operation)
+      end
+
+      ##
+      # Remove object
+      #
+      # @param [String]
+      # @return [Hash]
+      def remove(id)
+        client.delete("#{path}/#{id}")
+      end
+
+      ##
+      # Find object by id
+      #
+      # @param [String] id
+      # @return [Hash]
+      def find_one(id)
+        client.get("#{path}/#{id}")
+      end
+
+      ##
+      # Find objects
+      #
+      # @param [Hash] params
+      # @return [Array<Hash>]
+      def find(params = {})
+        if params[:q] && params[:q].is_a?(Hash)
+          params[:q] = params[:q].to_json
+        end
+        if params[:sort] && !params[:sort].is_a?(String)
+          params[:sort] = params[:sort].to_json
+        end
+        response = client.get("#{path}", params)
+        response['results']
+      end
+
+      ##
+      # Set object permissions
+      #
+      # @param [String]
+      def set_permissions(id, permissions)
+        client.post("#{path}/#{id}/access", permissions)
+      end
+
+      ##
+      # Add permissions
+      #
+      # @param [String] id
+      # @param [Hash] permissions
+      # @return [Hash]
+      def add_permissions(id, permissions)
+        client.put("#{path}/#{id}/access", permissions)
+      end
+
+      ##
+      # Remove permissions
+      #
+      # @param [String] id
+      # @param [Hash] permissions
+      # @return [Hash]
+      def remove_permissions(id, permissions)
+        client.delete("#{path}/#{id}/access", permissions)
+      end
+
+      protected
+
+      ##
+      # Get client
+      #
+      # @return [Qtc::Client]
+      def client
+        @client
+      end
+
+      ##
+      # Get path
+      #
+      # @return [String]
+      def path
+        @path
+      end
+    end
+  end
+end

data/lib/qtc/eds/user_collection.rb

@@ -0,0 +1,14 @@
+module Qtc
+  module Eds
+    class UserCollection < Collection
+
+      ##
+      # Initialize EDS user collection
+      #
+      # @param [Qtc::Client] client
+      def initialize(client)
+        super(client, '/users')
+      end
+    end
+  end
+end

data/lib/qtc/eds/usergroup_collection.rb

@@ -0,0 +1,42 @@
+module Qtc
+  module Eds
+    class UsergroupCollection < Collection
+
+      ##
+      # Initialize EDS usergroup collection
+      #
+      # @param [Qtc::Client] client
+      def initialize(client)
+        super(client, '/usergroups')
+      end
+
+      ##
+      # Add member to usergroup
+      #
+      # @param [String] id
+      # @param [Hash] user
+      def add_member(id, user)
+        client.post("#{path}/#{id}/members", user)
+      end
+
+      ##
+      # Remove member from usergroup
+      #
+      # @param [String] id
+      # @param [Hash] user
+      def remove_member(id, user)
+        client.delete("#{path}/#{id}/members", user)
+      end
+
+      ##
+      # Get usergroup members
+      #
+      # @param [String] id
+      # @return [Array<Hash>]
+      def members(id)
+        response = client.get("#{path}/#{id}/members")
+        response['results']
+      end
+    end
+  end
+end

data/lib/qtc/errors.rb

@@ -0,0 +1,11 @@
+module Qtc
+  module Errors
+    class StandardError < ::StandardError
+
+      def initialize(status, message)
+        @status = status
+        super(message)
+      end
+    end
+  end
+end

data/lib/qtc/mws/client.rb

@@ -0,0 +1,56 @@
+require 'faye/websocket'
+
+module Qtc
+  module Mws
+    class Client
+
+      DEFAULT_OPTIONS = {
+          api_url: 'https://mws-eu-1.qtc.io/v1'
+      }
+
+      attr_accessor :gateway_id, :options, :http_client
+
+      ##
+      # Initialize
+      #
+      # @param [String] gateway_id
+      # @param [Hash] options
+      def initialize(gateway_id, options = {})
+        self.gateway_id = opts[:gateway_id]
+        self.options = DEFAULT_OPTIONS.merge(options)
+        self.http_client = Qtc::Client.new(http_client_url)
+      end
+
+      ##
+      # Send message to websocket clients
+      #
+      # @param [String] message
+      # @param [Hash] receivers
+      # @option receivers [Array<String>] :sockets
+      # @option receivers [Array<String>] :tags
+      def send_message(message, receivers = {sockets: ['*'], tags: nil})
+        data = {data: message, receivers: receivers}
+        self.http_client.post('/messages', data)
+      end
+
+      ##
+      # Get websocket client
+      #
+      # @return [Faye::WebSocket::Client]
+      def websocket_client
+        uri = self.http_client.get('/websocket_uri')
+        Faye::WebSocket::Client.new(uri["uri"])
+      end
+
+      private
+
+      ##
+      # Get url for HTTPClient
+      #
+      # @return [String]
+      def http_client_url
+        "#{self.options[:api_url]}/gateways/#{self.gateway_id}"
+      end
+    end
+  end
+end

data/lib/qtc/version.rb

@@ -0,0 +1,3 @@
+module Qtc
+  VERSION = "0.0.1"
+end

data/lib/qtc-sdk.rb

@@ -0,0 +1,2 @@
+require 'qtc/client'
+require 'qtc/eds/client'

data/lib/qtc_cli.rb

@@ -0,0 +1,12 @@
+require 'thor'
+require 'qtc/client'
+require 'qtc/cli/instances'
+require 'qtc/cli/mar'
+
+class QtcCli < Thor
+  desc 'mar', 'Managed application runtime commands'
+  subcommand 'mar', Qtc::Cli::Mar
+
+  desc 'instances', 'Instances commands'
+  subcommand 'instances', Qtc::Cli::Instances
+end