Normal users can now create S3 DataProviders

The form to create DataProviders allow users to create three types of DPs now.

Also, the create_personal() action is available via API.

BrainPortal/app/controllers/data_providers_controller.rb

@@ -29,7 +29,7 @@ class DataProvidersController < ApplicationController
 
   api_available :only => [ :index, :show, :is_alive,
                            :browse, :register, :unregister, :delete,
-                           :create_personal, :check_personal, ]
+                           :create_personal, :check_personal, :destroy]
 
   before_action :login_required
   before_action :manager_role_required, :only => [:new, :create]
@@ -97,8 +97,8 @@ def create  #:nodoc:
       flash[:notice] = "Provider successfully created."
       respond_to do |format|
         format.html { redirect_to :action => :index, :format => :html}
-        format.xml  { render :xml   => @provider }
-        format.json { render :json  => @provider }
+        format.xml  { render :xml   => @provider.for_api }
+        format.json { render :json  => @provider.for_api }
       end
     else
       @typelist = get_type_list
@@ -115,25 +115,29 @@ def new_personal #:nodoc:
     @provider         = UserkeyFlatDirSshDataProvider.new( :user_id   => current_user.id,
                                                            :group_id  => provider_group_id,
                                                            :online    => true,
-                                                           :read_only => false
+                                                           :read_only => false,
                                                          )
     @groups           = current_user.assignable_groups
   end
 
-  # create by normal user,  only UserkeyFlatDirSshDataProvider
+  # Can be create by normal user,
+  # only UserkeyFlatDirSshDataProvider, S3FlatDataProvider, S3MultiLevelDataProvider
   def create_personal
-    normal_params = params.require_as_params(:data_provider)
-                          .permit(:name, :description, :group_id,
-                                  :remote_user, :remote_host,
-                                  :remote_port, :remote_dir
-                                 )
-    group_id = normal_params[:group_id]
-    current_user.assignable_group_ids.find(group_id) # ensure assignable, not sure need check visibility etc more
-    @provider         = UserkeyFlatDirSshDataProvider.new(normal_params)
-    @provider.user_id = current_user.id # prevent creation of dp on behalf of other users
+    @provider = DataProvider.new(base_provider_params).class_update
+    @provider.update_attributes(userkey_provider_params) if @provider.is_a?(UserkeyFlatDirSshDataProvider)
+    @provider.update_attributes(s3_provider_params)      if @provider.is_a?(S3FlatDataProvider)
+
+    authorized_type     = [UserkeyFlatDirSshDataProvider, S3FlatDataProvider, S3MultiLevelDataProvider]
+    @provider.errors.add(:type, "is not allowed") unless authorized_type.include?(@provider.type)
+
+    # Fix some attributes
+    @provider.user_id  = current_user.id
+    @provider.group_id = current_user.own_group.id unless
+      current_user.assignable_group_ids.include?(@provider.group_id)
+    @provider.online   = true
 
     if ! @provider.save
-      @groups   = current_user.assignable_groups
+      @groups = current_user.assignable_groups
       respond_to do |format|
         format.html { render :action => :new_personal}
         format.json { render :json   => @provider.errors,  :status => :unprocessable_entity }
@@ -149,7 +153,7 @@ def create_personal
 
     respond_to do |format|
       format.html { redirect_to :action => :show, :id => @provider.id}
-      format.json { render      :json   => @provider }
+      format.json { render      :json   => @provider.for_api }
     end
   end
 
@@ -1065,4 +1069,29 @@ def generate_register_response #:nodoc:
     }
   end
 
+  def base_provider_params #:nodoc:
+    params.require_as_params(:data_provider).permit(common_params_list)
+  end
+
+  def userkey_provider_params #:nodoc:
+    params.require_as_params(:data_provider).permit(userkey_params_list)
+  end
+
+  def s3_provider_params #:nodoc:
+    params.require_as_params(:data_provider).permit(s3_params_list)
+  end
+
+  def common_params_list #:nodoc:
+    [:name, :description, :group_id, :type]
+  end
+
+  def userkey_params_list #:nodoc:
+    [:remote_user, :remote_host, :remote_port, :remote_dir]
+  end
+
+  def s3_params_list #:nodoc:
+    [ :cloud_storage_client_identifier, :cloud_storage_client_token,
+      :cloud_storage_client_bucket_name, :cloud_storage_client_path_start,
+      :cloud_storage_endpoint, :cloud_storage_region]
+  end
 end

BrainPortal/app/models/s3_flat_data_provider.rb

@@ -60,6 +60,8 @@ class S3FlatDataProvider < DataProvider
 
   before_save :canonify_path_start
 
+  api_attr_visible :cloud_storage_client_bucket_name, :cloud_storage_client_path_start, :cloud_storage_endpoint, :cloud_storage_region
+
   # This returns the category of the data provider
   def self.pretty_category_name #:nodoc:
     "Cloud"
@@ -442,4 +444,14 @@ def rsync_emulation(src_fileinfos,dst_fileinfos) #:nodoc:
            ]
   end
 
+  #################################################################
+  # Model Callbacks
+  #################################################################
+
+  # Normally, DPs can only be owned by admins. However, this DP class
+  # can be owned by normal users.
+  def owner_is_appropriate #:nodoc:
+    return true
+  end
+
 end

BrainPortal/app/models/userkey_flat_dir_ssh_data_provider.rb

@@ -30,6 +30,8 @@ class UserkeyFlatDirSshDataProvider < FlatDirSshDataProvider
 
   validates_presence_of :remote_user, :remote_host, :remote_dir
 
+  api_attr_visible :remote_user, :remote_host, :remote_dir, :remote_port
+
   def impl_is_alive? #:nodoc:
     user = self.user # we use the owner as the way to check if it's alive
     return false unless self.master(user, nil).is_alive?