synology 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 691973268b923bf903f848351db9525ed49d3b856e844a98dd705cc6d0d135f4
+  data.tar.gz: 8098dcffd55f22c2ed5b1c614109bdf7e1b2b4c123010c46dfd9a60521553c03
+SHA512:
+  metadata.gz: d512713deba8261ea8eb57f7db8c94ac4ab15ec08d9973f4df726df168adf82530c5ecf5ff135833e68104de0ed86fc7c1a9ae85d9c63558b806e5595408e2aa
+  data.tar.gz: '08d006a8c22509960393172d0d640a4958aaa135ffb085260476434b5b45446d66511ecd8ff986124d8d15a72df9ed40dc8cb5d9aa8d8a4f8206979d64667962'

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Henry Maestu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,166 @@
+# Synology
+
+Synology NAS API client written in Ruby.
+
+Full implantation of Synology API based on this documentation: https://global.download.synology.com/download/Document/Software/DeveloperGuide/Package/FileStation/All/enu/Synology_File_Station_API_Guide.pdf
+
+## Installation
+
+```ruby
+gem 'synology'
+```
+
+And then execute:
+
+    $ bundle install
+
+
+## Usage
+
+Have some other Synology Service exposed define endpoints in config. 
+```
+Synology.configure do |config|
+ 
+  ....
+  # Define your own endpoints
+  # May break code with POST request...
+  # Example: lib/synology/client.rb  
+  config.api_endpoint = { 
+     info: { api: 'SYNO.FileStation.Info', version: 2, method: 'get', http_method: 'GET' },
+     # SYNO.API.Auth
+     login: { api: 'SYNO.API.Auth', version: 3, method: 'login', http_method: 'GET' },
+     logout: { api: 'SYNO.API.Auth', version: 1, method: 'logout', http_method: 'GET' }
+    ...
+  }
+end
+```
+
+### Basic usages
+
+```
+Synology.configure do |config|
+  config.host = 'https://finds.synology.com'
+  config.username = 'admin'
+  config.password = 'password'
+  config.https = true
+end
+
+client = Synology::Client.new
+# Login
+client.login(account: client.username, passwd: client.password)
+
+# List files in folder
+client.list_folder(folder_path: '/my_folder', additional: '["real_path", "size", "owner"]')
+
+# Upload a file
+client.upload(path: '/my_folder', file: {file_name:'testing', file_content: 'Testing123'})
+# Download a file body Base64.strict_encoded
+client.download(path: '/my_folder/testing')
+
+client.close
+
+```
+
+Authentication Methods
+
+    client.login(account: , passwd:)# Authenticate with Synology NAS
+    client.logout # End the current session
+
+#### File and Folder Operations
+
+List & Info
+
+    client.list_share # List all shared folders
+    client.list_folder(folder_path:, additional:) # List contents of a folder
+    client.list_get_info # Get information about files/folders
+
+Search Operations
+
+    client.search_start(folder_path:, pattern:) # Start a search operation
+    client.search_list(taskid:) # List search results
+    client.search_stop(taskid:) # Stop a search operation
+    client.search_clean(taskid:) # Clean up search results
+
+Virtual Folder Operations
+
+    client.list_all_mount_points(type:, additional:) # List mount points of virtual file systems
+
+Favorite Management
+
+    client.favorite_list # List favorite folders
+    client.favorite_add(path:, name:) # Add folder to favorites
+    client.favorite_edit(path:, name:) # Edit favorite folder
+    client.favorite_delete(path:) # Remove from favorites
+    client.favorite_clear_broken # Clear broken favorite links
+
+Thumbnail Operations
+
+    client.get_thumbnail(path:) # Get thumbnail of a file
+
+Directory Operations
+
+    client.dir_start(path:) # Start directory size calculation
+    client.dir_status(taskid:) # Check directory size calculation status
+    client.dir_stop(taskid:) # Stop directory size calculation
+
+MD5 Operations
+
+    client.md5_start(file_path:) # Start MD5 calculation
+    client.md5_status(taskid:) # Check MD5 calculation status
+    client.md5_stop(taskid:) # Stop MD5 calculation
+
+#### File Management
+
+Basic Operations
+
+    client.check_permission(path:, filename:) # Check file/folder permissions
+    client.upload(path:, file:{file_name:, file_content:}) # Upload files
+    client.download(path:) # Download files
+    client.create_folder(folder_path:, name:) # Create new folder
+    client.rename(path:, name:) # Rename file/folder
+    client.delete(path:) # Delete file/folder immediately
+
+Sharing Operations
+
+    client.sharing_get_info(id:) # Get sharing link info
+    client.sharing_links_list # List all sharing links
+    client.sharing_link_create(path:) # Create sharing link
+    client.sharing_link_delete(id:) # Delete sharing link
+    client.sharing_link_edit(id:) # Edit sharing link
+    client.sharing_link_clear_invalid # Clear invalid sharing links
+
+Asynchronous Operations
+
+    client.copy_move_start(path:, dest_folder_path:) # Start copy/move operation
+    client.copy_move_status(taskid:) # Check copy/move status
+    client.copy_move_stop(taskid:) # Stop copy/move operation
+
+Delete Operations
+
+    client.delete_async_start(path:) # Start asynchronous delete
+    client.delete_async_status(taskid:) # Check delete status
+    client.delete_async_stop(taskid:) # Stop delete operation
+
+Archive Operations
+
+    client.extract_start(file_path:, dest_folder_path:) # Start extraction
+    client.extract_status(taskid:) # Check extraction status
+    client.extract_stop(taskid:) # Stop extraction
+    client.extract_list(file_path:) # List archive contents
+    client.compress_start(path:, dest_file_path:) # Start compression
+    client.compress_status(taskid:) # Check compression status
+    client.compress_stop(taskid:) # Stop compression
+    client.compress_list(file_path:) # List compressed file contents
+
+Background Tasks
+
+    client.background_task_list # List background tasks
+    client.background_task_clear_finished(taskid:) # Clear finished background tasks
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/dragonwebeu/synology.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/synology/client.rb

@@ -0,0 +1,286 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+require 'uri'
+require 'openssl'
+require 'base64'
+
+module Synology
+  class Client
+    API_ENDPOINT = 'webapi/entry.cgi'
+
+    # API endpoints definition using metaprogramming
+    # https://global.download.synology.com/download/Document/Software/DeveloperGuide/Package/FileStation/All/enu/Synology_File_Station_API_Guide.pdf
+    API_ENDPOINTS = {
+      info: { api: 'SYNO.FileStation.Info', version: 2, method: 'get', http_method: 'GET' },
+      # SYNO.API.Auth
+      login: { api: 'SYNO.API.Auth', version: 3, method: 'login', http_method: 'GET' },
+      logout: { api: 'SYNO.API.Auth', version: 1, method: 'logout', http_method: 'GET' },
+      # SYNO.FileStation.List
+      list: {
+        #client.list_share
+        share: { api: 'SYNO.FileStation.List', version: 2, method: 'list_share', http_method: 'GET' },
+        # client.list_folder(folder_path: '/my_folder', additional: '["real_path", "size", "owner"]')
+        folder: { api: 'SYNO.FileStation.List', version: 2, method: 'list', http_method: 'GET' },
+        get_info: { api: 'SYNO.FileStation.List', version: 2, method: 'getinfo', http_method: 'GET' }
+      },
+      # SYNO.FileStation.Search
+      search: {
+          # client.search_start(folder_path: '/my_folder', pattern: 'test')
+          start: { api: 'SYNO.FileStation.Search', version: 2, method: 'start', http_method: 'GET' },
+          # client.search_list(taskid: '173126991043E83CB8')
+          list: { api: 'SYNO.FileStation.Search', version: 2, method: 'list', http_method: 'GET' },
+          # client.search_stop(taskid: '173126991043E83CB8')
+          stop: { api: 'SYNO.FileStation.Search', version: 2, method: 'stop', http_method: 'GET' },
+          # client.search_clean(taskid: '173126991043E83CB8')
+          clean: { api: 'SYNO.FileStation.Search', version: 2, method: 'clean', http_method: 'GET' }
+      },
+      # SYNO.FileStation.VirtualFolder
+      # List all mount point folders of virtual file system, e.g., CIFS or ISO
+      # client.list_all_mount_points(type: 'cifs', additional: '["real_path","owner","time","perm","mount_point_type","volume_status"]')
+      list_all_mount_points: { api: 'SYNO.FileStation.VirtualFolder', version: 2, method: 'list', http_method: 'GET' },
+      favorite: {
+          # client.favorite_list
+          list: { api: 'SYNO.FileStation.Favorite', version: 2, method: 'list', http_method: 'GET' },
+          # client.favorite_add(path: '/my_folder', name: 'Henry')
+          add: { api: 'SYNO.FileStation.Favorite', version: 2, method: 'add', http_method: 'GET' },
+          # client.favorite_edit(path: '/my_folder', name: 'Henry2')
+          edit: { api: 'SYNO.FileStation.Favorite', version: 2, method: 'add', http_method: 'GET' },
+          # client.favorite_delete(path: '/my_folder')
+          delete: { api: 'SYNO.FileStation.Favorite', version: 2, method: 'delete', http_method: 'GET' },
+          # client.favorite_clear_broken
+          clear_broken: { api: 'SYNO.FileStation.Favorite', version: 2, method: 'clear_broken', http_method: 'GET' }
+      },
+      # SYNO.FileStation.Thumb
+      # Get a thumbnail of a file.
+      # client.get_thumbnail(path:'/my_folder')
+      get_thumbnail: { api: 'SYNO.FileStation.Thumb', version: 2, method: 'get', http_method: 'GET' },
+      # SYNO.FileStation.DirSize
+      dir: {
+          # client.dir_start(path: '/my_folder')
+          start: { api: 'SYNO.FileStation.DirSize', version: 2, method: 'start', http_method: 'GET' },
+          # client.dir_status(taskid: '1731273375F0B260B3')
+          status: { api: 'SYNO.FileStation.DirSize', version: 2, method: 'status', http_method: 'GET' },
+          # client.dir_stop(taskid: '1731273375F0B260B3')
+          stop: { api: 'SYNO.FileStation.DirSize', version: 2, method: 'status', http_method: 'GET' }
+      },
+      # SYNO.FileStation.MD5
+      md5: {
+          # client.md5_start(file_path: '/my_folder/some_move.mov')
+          start: { api: 'SYNO.FileStation.MD5', version: 2, method: 'start', http_method: 'GET' },
+          # client.md5_status(taskid: '1731274183A791CF18')
+          status: { api: 'SYNO.FileStation.MD5', version: 2, method: 'status', http_method: 'GET' },
+          # client.md5_stop(taskid: '1731274183A791CF18')
+          stop: { api: 'SYNO.FileStation.MD5', version: 2, method: 'stop', http_method: 'GET' }
+      },
+      # SYNO.FileStation.CheckPermission
+      # client.check_permission(path: '', filename: '')
+      check_permission: { api: 'SYNO.FileStation.CheckPermission', version: 3, method: 'write', http_method: 'GET' },
+      #SYNO.FileStation.Upload
+      # upload = client.upload(path: '/my_folder', file: {file_name:'testing', file_content: 'Testing123'})
+      upload: { api: 'SYNO.FileStation.Upload', version: 2, method: 'upload', http_method: 'POST' }, # Only POST method in the API
+      # download_file = client.download(path: '/my_folder/testing')
+      download: { api: 'SYNO.FileStation.Download', version: 2, method: 'download', http_method: 'GET' },
+      # SYNO.FileStation.Sharing
+      sharing: {
+          # sharing_link = client.sharing_get_info(id: '12345')
+          get_info: { api: 'SYNO.FileStation.Sharing', version: 3, method: 'getinfo', http_method: 'GET' },
+          # client.sharing_links_list
+          links_list: { api: 'SYNO.FileStation.Sharing', version: 3, method: 'list', http_method: 'GET' },
+          # client.sharing_link_create(path: '/my_folder')
+          link_create: { api: 'SYNO.FileStation.Sharing', version: 3, method: 'create', http_method: 'GET' },
+          # client.sharing_link_delete(id: '12345')
+          link_delete: { api: 'SYNO.FileStation.Sharing', version: 3, method: 'delete', http_method: 'GET' },
+          # # client.sharing_link_edit(id: '12345')
+          link_edit: { api: 'SYNO.FileStation.Sharing', version: 3, method: 'edit', http_method: 'GET' },
+          # client.sharing_link_clear_invalid
+          link_clear_invalid: { api: 'SYNO.FileStation.Sharing', version: 3, method: 'clear_invalid', http_method: 'GET' }
+      },
+      # SYNO.FileStation.CreateFolder
+      # client.create_folder(folder_path: '/my_folder', name: 'testing1')
+      create_folder: { api: 'SYNO.FileStation.CreateFolder', version: 2, method: 'create', http_method: 'GET' },
+      # SYNO.FileStation.Rename
+      # client.rename(path: '/my_folder/Testing1', name: 'Testing2')
+      rename: { api: 'SYNO.FileStation.Rename', version: 2, method: 'rename', http_method: 'GET' },
+      # SYNO.FileStation.CopyMove
+      copy_move: {
+          # client.copy_move_start(path: '/my_folder/testing', dest_folder_path: '/my_folder/Testing2')
+          start: { api: 'SYNO.FileStation.CopyMove', version: 3, method: 'start', http_method: 'GET' },
+          # client.copy_move_status(taskid: 'FileStation_51D00B7912CDE0B0')
+          status: { api: 'SYNO.FileStation.CopyMove', version: 3, method: 'status', http_method: 'GET' },
+          # client.copy_move_stop(taskid: 'FileStation_51D00B7912CDE0B0')
+          stop: { api: 'SYNO.FileStation.CopyMove', version: 3, method: 'stop', http_method: 'GET' },
+      },
+      # SYNO.FileStation.Delete
+      #
+      delete_async: {
+          # client.delete_async_start(path: '/my_folder/testing')
+          start: { api: 'SYNO.FileStation.Delete', version: 2, method: 'start', http_method: 'GET' },
+          # client.delete_async_status(taskid: 'FileStation_51CEC9C979340E5A')
+          status: { api: 'SYNO.FileStation.Delete', version: 2, method: 'status', http_method: 'GET' },
+          # client.delete_async_stop(taskid: 'FileStation_51CEC9C979340E5A')
+          stop: { api: 'SYNO.FileStation.Delete', version: 2, method: 'stop', http_method: 'GET' }
+      },
+      # client.delete(path: '/my_folder/testing')
+      delete: { api: 'SYNO.FileStation.Delete', version: 2, method: 'delete', http_method: 'GET' },
+      # SYNO.FileStation.Extract
+      extract: {
+        # client.extract_start(file_path: '/my_folder/testing.zip', dest_folder_path: '/my_folder')
+        start: { api: 'SYNO.FileStation.Extract', version: 2, method: 'start', http_method: 'GET' },
+        # client.extract_status(taskid: 'FileStation_51CBB59C68EFE6A3')
+        status: { api: 'SYNO.FileStation.Extract', version: 2, method: 'status', http_method: 'GET' },
+        # client.extract_stop(taskid: 'FileStation_51CBB59C68EFE6A3')
+        stop: { api: 'SYNO.FileStation.Extract', version: 2, method: 'stop', http_method: 'GET' },
+        # client.extract_list(file_path: '/my_folder/testing.zip')
+        list: { api: 'SYNO.FileStation.Extract', version: 2, method: 'list', http_method: 'GET' }
+      },
+      #SYNO.FileStation.Compress
+      compress: {
+          # client.compress_start(path: '/my_folder/testing', dest_file_path: '/my_folder')
+          start: { api: 'SYNO.FileStation.Compress', version: 3, method: 'start', http_method: 'GET' },
+          # client.compress_status(taskid: 'FileStation_51CBB25CC31961FD')
+          status: { api: 'SYNO.FileStation.Compress', version: 3, method: 'status', http_method: 'GET' },
+          # client.compress_stop(taskid: 'FileStation_51CBB25CC31961FD')
+          stop: { api: 'SYNO.FileStation.Compress', version: 3, method: 'stop', http_method: 'GET' },
+          # client.compress_list(file_path: '/my_folder/testing.zip')
+          list: { api: 'SYNO.FileStation.Compress', version: 3, method: 'status', http_method: 'GET' }
+      },
+      background_task: {
+        # client.background_task_list
+        list: { api: 'SYNO.FileStation.BackgroundTask', version: 3, method: 'list', http_method: 'GET' },
+        # client.background_task_clear_finished(taskid: 'FileStation_51D530978633C014')
+        clear_finished: { api: 'SYNO.FileStation.BackgroundTask', version: 3, method: 'clear_finished', http_method: 'GET' }
+      }
+    }
+
+
+    attr_reader :username, :password
+    attr_accessor :sid
+
+    def initialize
+      @config = Synology.configuration
+      @username = @config.username
+      @password = @config.password
+      @sid = nil
+      @api_endpoint = @config.api_endpoint || API_ENDPOINT
+      # API_ENDPOINTS
+      @api_endpoints = @config.api_endpoints || API_ENDPOINTS
+      generate_api_methods
+    end
+
+    private
+
+    def generate_api_methods
+      @api_endpoints.each do |method_name, endpoints|
+        unless endpoints.dig(:api)
+          endpoints.each do |method_name2, endpoints2|
+            nested_method_name = "#{method_name}_#{method_name2}"
+            define_singleton_method(nested_method_name) do |params = {}|
+              execute_request(endpoints2, params)
+            end
+          end
+        else
+          define_singleton_method(method_name) do |params = {}|
+            execute_request(endpoints, params)
+          end
+        end
+      end
+    end
+
+    def execute_request(endpoint_info, params)
+      uri = URI("#{@config.base_url}/#{API_ENDPOINT}/#{endpoint_info[:path]}")
+      request_params = {
+          api: endpoint_info[:api],
+          version: endpoint_info[:version],
+          method: endpoint_info[:method]
+      }.merge(params)
+
+      # Todo: cleanup or get sid other way
+      request_params[:_sid] = @sid if @sid && @use_cookies
+
+      response = make_request(uri, request_params, endpoint_info[:http_method])
+      handle_response(response, request_params)
+    end
+
+    def make_request(uri, params, request_type='GET')
+      # Todo: find better solution for this
+      if params[:method] == 'upload'
+        file = params[:file]
+        params.delete(:file)
+
+        if file[:file_content].nil?
+          raise "File content can't be nil!"
+        end
+      end
+      uri.query = URI.encode_www_form(params)
+      https = Net::HTTP.new(uri.host, uri.port)
+      if @config.https
+        https.use_ssl = true
+        # https.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      end
+
+      request = Net::HTTP::Get.new(uri) if request_type.upcase == 'GET'
+      if request_type.upcase == 'POST'
+        request = Net::HTTP::Post.new(uri)
+        boundary = rand(100000)
+        request.body = upload_body(params, file, boundary).join
+        request["Content-Type"] = "multipart/form-data; boundary=#{boundary}"
+      end
+      unless @sid.nil?
+        request['Cookie'] = "#{@sid}"
+      end
+      response = https.request(request)
+      if response.header['set-cookie']
+        @sid = response.header['set-cookie']
+      end
+      response
+    end
+
+    def handle_response(response, params)
+      # Todo: Cleanup this later and find better solution
+      if params[:method] == 'download' && response.code == '200'
+        response.body = {body: Base64.strict_encode64(response.body), content_type: response['Content-Type'], success: true}.to_json
+      end
+      if response.is_a?(Net::HTTPSuccess)
+        return parse_json(response.body, params)
+      end
+
+      raise Error, "HTTP Request failed: #{response.code} #{response.message}"
+    end
+
+    def parse_json(body, params)
+      json_body = JSON.parse(body)
+      # Todo: Change is so it runnable by config settings
+      unless json_body['error'].nil?
+        Synology::Error.raise_error(json_body['error']['code'], params[:api])
+      end
+      json_body
+    rescue JSON::ParserError
+      raise Error, "Invalid JSON response"
+    end
+
+    def upload_body(params, file, boundary)
+      post_body = []
+      post_body << upload_params_to_form_data(params, boundary)
+      post_body << "--#{boundary}\r\n"
+      post_body << "Content-Disposition: form-data; name=\"file\"; filename=\"#{file[:file_name]}\"\r\n"
+      post_body << "Content-Type: application/octet-stream\r\n\r\n"
+      post_body << file[:file_content]
+      post_body << "\r\n--#{boundary}--\r\n"
+      post_body
+    end
+
+    def upload_params_to_form_data(params, boundary)
+      params_body = []
+      params.each do |param|
+        params_body << "--#{boundary}\r\n"
+        params_body << "Content-Disposition: form-data; name=\"#{param[0].to_s}\"\r\n\r\n"
+        params_body << "#{param[1].to_s}\r\n"
+      end
+      params_body
+    end
+
+
+  end
+end

data/lib/synology/configuration.rb

@@ -0,0 +1,19 @@
+module Synology
+  class Configuration
+    attr_accessor :host, :port, :username, :password, :use_cookies, :https, :api_endpoints, :api_endpoint, :parse_errors
+
+    def initialize
+      @api_endpoints = nil
+      @api_endpoint = nil
+      # Syno default port
+      @port = 5000
+      @https = false
+      @use_cookies = true
+      @parse_errors = true
+    end
+
+    def base_url
+      "#{https ? 'https' : 'http'}://#{host}:#{port}"
+    end
+  end
+end

data/lib/synology/error.rb

@@ -0,0 +1,140 @@
+module Synology
+  class Error < StandardError
+
+    COMMON_ERRORS = {
+        100 => "Unknown error",
+        101 => "No parameter of API, method or version",
+        102 => "The requested API does not exist",
+        103 => "The requested method does not exist",
+        104 => "The requested version does not support the functionality",
+        105 => "The logged in session does not have permission",
+        106 => "Session timeout",
+        107 => "Session interrupted by duplicate login",
+        119 => "SID not found",
+        400 => "Invalid parameter of file operation",
+        401 => "Unknown error of file operation",
+        402 => "System is too busy",
+        403 => "Invalid user does this file operation",
+        404 => "Invalid group does this file operation",
+        405 => "Invalid user and group does this file operation",
+        406 => "Can't get user/group information from the account server",
+        407 => "Operation not permitted",
+        408 => "No such file or directory",
+        409 => "Non-supported file system",
+        410 => "Failed to connect internet-based file system (e.g., CIFS)",
+        411 => "Read-only file system",
+        412 => "Filename too long in the non-encrypted file system",
+        413 => "Filename too long in the encrypted file system",
+        414 => "File already exists",
+        415 => "Disk quota exceeded",
+        416 => "No space left on device",
+        417 => "Input/output error",
+        418 => "Illegal name or path",
+        419 => "Illegal file name",
+        420 => "Illegal file name on FAT file system",
+        421 => "Device or resource busy",
+        599 => "No such task of the file operation"
+    }
+
+    AUTH_ERRORS = {
+        400 => "No such account or incorrect password",
+        401 => "Account disabled",
+        402 => "Permission denied",
+        403 => "2-step verification code required",
+        404 => "Failed to authenticate 2-step verification code"
+    }
+
+    # SYNO.FileStation.Favorite
+    FAVORITE_ERRORS = {
+        800 => "A folder path of favorite folder is already added to user's favorites",
+        801 => "A name of favorite folder conflicts with an existing folder path in the user's favorites",
+        802 => "There are too many favorites to be added"
+    }
+
+    UPLOAD_ERRORS = {
+        1800 => "There is no Content-Length information in the HTTP header or the received size doesn't match the value of Content-Length information in the HTTP header",
+        1801 => "Wait too long, no date can be received from client (Default maximum wait time is 3600 seconds)",
+        1802 => "No filename information in the last part of file content",
+        1803 => "Upload connection is cancelled",
+        1804 => "Failed to upload oversized file to FAT file system",
+        1805 => "Can't overwrite or skip the existing file, if no overwrite parameter is given"
+    }
+
+    SHARING_ERRORS = {
+        2000 => "Sharing link does not exist",
+        2001 => "Cannot generate sharing link because too many sharing links exist",
+        2002 => "Failed to access sharing links"
+    }
+
+    CREATE_FOLDER_ERRORS = {
+        1100 => "Failed to create a folder. More information in <errors> object",
+        1101 => "The number of folders to the parent folder would exceed the system limitation"
+    }
+
+    RENAME_ERRORS = {
+        1200 => "Failed to rename it. More information in <errors> object"
+    }
+
+    COPY_MOVE_ERRORS = {
+        1000 => "Failed to copy files/folders. More information in <errors> object",
+        1001 => "Failed to move files/folders. More information in <errors> object",
+        1002 => "An error occurred at the destination. More information in <errors> object",
+        1003 => "Cannot overwrite or skip the existing file because no overwrite parameter is given",
+        1004 => "File cannot overwrite a folder with the same name, or folder cannot overwrite a file with the same name",
+        1006 => "Cannot copy/move file/folder with special characters to a FAT32 file system",
+        1007 => "Cannot copy/move a file bigger than 4G to a FAT32 file system"
+    }
+
+    DELETE_ERRORS = {
+        900 => "Failed to delete file(s)/folder(s). More information in <errors> object"
+    }
+
+    EXTRACT_ERRORS = {
+        1400 => "Failed to extract files",
+        1401 => "Cannot open the file as archive",
+        1402 => "Failed to read archive data error",
+        1403 => "Wrong password",
+        1404 => "Failed to get the file and dir list in an archive",
+        1405 => "Failed to find the item ID in an archive file"
+    }
+
+    COMPRESS_ERRORS = {
+        1300 => "Failed to compress files/folders",
+        1301 => "Cannot create the archive because the given archive name is too long"
+    }
+
+    class << self
+
+      attr_reader :code
+
+      def initialize(message = nil, code = nil)
+        @code = code
+        super(message)
+      end
+
+      def get_error_message(code, operation = nil)
+        # Todo: Find cleaner better way, We dont merge because of duplicate keys.
+        error_map = case operation
+                    when 'SYNO.API.Auth' then AUTH_ERRORS
+                    when 'SYNO.FileStation.Favorite' then FAVORITE_ERRORS.merge(COMMON_ERRORS)
+                    when 'SYNO.FileStation.Upload' then UPLOAD_ERRORS.merge(COMMON_ERRORS)
+                    when 'SYNO.FileStation.Sharing' then SHARING_ERRORS.merge(COMMON_ERRORS)
+                    when 'SYNO.FileStation.CreateFolder' then CREATE_FOLDER_ERRORS.merge(COMMON_ERRORS)
+                    when 'SYNO.FileStation.Rename' then RENAME_ERRORS.merge(COMMON_ERRORS)
+                    when 'SYNO.FileStation.CopyMove' then COPY_MOVE_ERRORS.merge(COMMON_ERRORS)
+                    when 'SYNO.FileStation.Delete' then DELETE_ERRORS.merge(COMMON_ERRORS)
+                    when 'SYNO.FileStation.Extract' then EXTRACT_ERRORS.merge(COMMON_ERRORS)
+                    when 'SYNO.FileStation.Compress' then COMPRESS_ERRORS.merge(COMMON_ERRORS)
+                    else COMMON_ERRORS
+                    end
+
+        error_map[code] || COMMON_ERRORS[code] || "Unknown error (Code: #{code})"
+      end
+
+      def raise_error(code, operation = nil)
+        message = get_error_message(code, operation)
+        raise new("#{message} (Error Code: #{code})")
+      end
+    end
+  end
+end

data/lib/synology/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Synology
+  VERSION = "0.1.0"
+end

data/lib/synology.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "synology/configuration"
+require_relative "synology/client"
+require_relative "synology/version"
+require_relative "synology/error"
+
+module Synology
+  class << self
+    attr_accessor :configuration
+  end
+
+  def self.configure
+    self.configuration ||= Configuration.new
+    yield(configuration) if block_given?
+  end
+end

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification
+name: synology
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Henry Maestu
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2024-11-11 00:00:00.000000000 Z
+dependencies: []
+description: Synology NAS API client written in Ruby
+email:
+- dragonwebeu@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/synology.rb
+- lib/synology/client.rb
+- lib/synology/configuration.rb
+- lib/synology/error.rb
+- lib/synology/version.rb
+homepage: https://github.com/dragonwebeu/synology
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/dragonwebeu/synology
+  source_code_uri: https://github.com/dragonwebeu/synology
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.1
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.9
+signing_key: 
+specification_version: 4
+summary: Synology API Client in Ruby
+test_files: []