Add autogeneration of gd2 api methods from endpoints API

Author: Shirshendu Mukherjee

app/controllers/clusters_controller.rb

@@ -1,50 +1,54 @@
 class ClustersController < AuthenticatedUsersController
   get '/clusters' do
-    clusters = Tendrl::Cluster.all
-    JSON.generate clusters: clusters
+    clusters = Tendrl::Cluster.all.map do |c|
+      c.gd2.statedump.to_h
+    end
+    { clusters: clusters }.to_json
   end
 
   before '/clusters/:cluster_id/?*?' do
     @cluster = Tendrl::Cluster.find(params[:cluster_id])
-    raise Tendrl::HttpResponseErrorHandler.new(
-      StandardError.new,
-      cause: '/clusters/id',
-      object_id: params[:cluster_id]
-    )
+    unless @cluster.present?
+      raise Tendrl::HttpResponseErrorHandler.new(
+        StandardError.new,
+        cause: '/clusters/id',
+        object_id: params[:cluster_id]
+      )
+    end
   end
 
   get '/clusters/:cluster_id' do
-    state = @cluster.gd2.state
-    state.to_json
+    @cluster.gd2.statedump
   end
 
   get '/clusters/:cluster_id/peers' do
-    peers = @cluster.gd2.peers
+    peers = @cluster.gd2.get_peers.to_a
     { peers: peers }.to_json
   end
 
   get '/clusters/:cluster_id/volumes' do
-    volumes = @cluster.gd2.volumes
+    volumes = @cluster.gd2.volume_list.to_a
     { volumes: volumes }.to_json
   end
 
-  get '/clusters/:cluster_id/volumes/:volume_id' do
-    volume = @cluster.gd2.volumes(params[:volume_id])
+  get '/clusters/:cluster_id/volumes/:volname' do
+    volume = @cluster.gd2.volume_info(params[:volname]).to_a
     { volume: volume }.to_json
   end
 
-  get '/clusters/:cluster_id/volumes/:volume_id/bricks' do
-    bricks = @cluster.gd2.bricks(params[:volume_id])
+  get '/clusters/:cluster_id/volumes/:volname/bricks' do
+    bricks = @cluster.gd2.volume_bricks_status(params[:volname]).to_a
     { bricks: bricks }.to_json
   end
 
   post '/import' do
     new_endpoint = {
       'gd2_url' => parsed_body['gd2_url'],
+      'user' => parsed_body['user'],
       'secret' => parsed_body['secret']
     }
-    gd2 = Gd2Client.new new_endpoint.symbolize_keys
-    state = gd2.state
+    gd2 = Gd2Client.new new_endpoint
+    state = gd2.statedump
     cluster = Tendrl::Cluster.new state['cluster-id']
     unless cluster.endpoints.include? new_endpoint
       cluster.add_endpoint new_endpoint

app/models/cluster.rb

@@ -15,11 +15,11 @@ def endpoints
     end
 
     def gd2
-      @gd2 ||= endpoints.map { |e| Gd2Client.from_endpoint e }.find(&:ping?)
+      @gd2 ||= endpoints.map { |e| Gd2Client.new e }.find(&:ping?)
     end
 
     def to_json(_)
-      gd2.state.merge(endpoints: endpoints).to_json
+      gd2.statedump.merge(endpoints: endpoints).to_json
     end
 
     def add_endpoint(endpoint)
@@ -33,7 +33,7 @@ def add_endpoint(endpoint)
     class << self
       def find(cluster_id)
         cluster = new(cluster_id)
-        return nil unless cluster.gd2.present?
+        cluster.gd2.present? ? cluster : nil
       end
 
       def all

lib/gd2_client.rb

@@ -1,23 +1,27 @@
 class Gd2Client
   include HTTParty
 
-  def self.from_endpoint(endpoint)
-    new(gd2_url: endpoint['gd2_url'], secret: endpoint['secret'])
+  UNVERSIONED_APIS = %w[/version /ping /statedump /endpoints]
+
+  def initialize(endpoint)
+    endpoint = endpoint.with_indifferent_access
+    @gd2_url = endpoint[:gd2_url]
+    @user = endpoint[:user].present? ? endpoint[:user] : 'glustercli'
+    @secret = endpoint[:secret] || File.read(File.join('var', 'lib', 'glusterd2', 'auth'))
+    generate_api_methods
   end
 
-  def initialize(gd2_url: 'http://localhost:24007', user: 'glustercli', secret: nil)
-    @gd2_url = gd2_url
-    @secret = secret || File.read(File.join('var', 'lib', 'glusterd2', 'auth'))
-    @claim = {
-      iss: user,
+  def claim(method, path)
+    {
+      iss: @user,
       iat: DateTime.now.utc,
       exp: DateTime.now.utc + 10.seconds,
-      qsh: ''
+      qsh: Digest::SHA256.hexdigest(method.to_s.upcase + '&' + path)
     }
   end
 
-  def jwt_token
-    JWT.encode(@claim, @secret, 'HS256')
+  def jwt_token(method, path)
+    JWT.encode(claim(method, path), @secret, 'HS256')
   end
 
   def respond_to_missing?(method, include_private = false)
@@ -30,41 +34,39 @@ def method_missing(m, *args, &block)
   end
 
   def http_call(method, path, opts = {})
-    @claim[:qsh] = Digest::SHA256.hexdigest(method.to_s.upcase + '&' + path)
-    response = HTTParty.public_send(
+    req_data = { headers: { 'Authorization' => 'Bearer ' + jwt_token(method, path) } }
+    req_data[:body] = args[-1].to_h if %w[put post patch].include?(method) && args[-1].respond_to(:to_h)
+    HTTParty.public_send(
       method,
       @gd2_url + path,
-      opts.merge(headers: { 'Authorization' => 'Bearer ' + jwt_token })
+      opts.merge(req_data)
     )
-    return JSON.parse(response.body) if response.success?
-    raise Tendrl::HttpResponseErrorHandler.new(StandardError.new, cause: 'gd2_api_error', object_id: method.to_s.capitalize + path.to_s)
-  end
-
-  def peers
-    get('/v1/peers')
-  end
-
-  def state
-    get('/statedump')
-  end
-
-  def volumes
-    get('/v1/volumes')
   end
 
-  def volume(vol_name)
-    get("/v1/volumes/#{vol_name}")
+  def prefixed_path(path)
+    UNVERSIONED_APIS.include?(path) ? path : '/v1' + path
   end
 
-  def bricks(vol_name)
-    get("/v1/volumes/#{vol_name}/bricks")
+  def generate_api_methods
+    apis.each do |api|
+      method_name = api['name'].split.join('_').underscore
+      action = api['methods'].downcase
+      self.class.send(:define_method, method_name) do |*args|
+        path = api['path'].gsub(/{.*?}/).with_index { |_, i| args[i] }
+        path = prefixed_path(path)
+        response = http_call(action, path, args[-1].present? && args[-1].respond_to?(:to_h) ? args[-1] : {})
+        return response if response.success?
+        raise Tendrl::HttpResponseErrorHandler.new(response.body, cause: 'gd2_api_error', object_id: api['methods'] + path.to_s)
+      end
+    end
+    self
   end
 
   def ping?
-    HTTParty.get(@gd2_url + "/ping").success?
+    HTTParty.get(@gd2_url + '/ping').success?
   end
 
-  def endpoints
-    get('/endpoints')
+  def apis
+    get('/endpoints').to_a
   end
 end