remotesync 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 13cc5deafe2ae0fa3348ac64b6212feef2b8df773b4005a49d134652e86a99d4
+  data.tar.gz: 9cb6df03332a34df4320776273ec54b4327b1f49cae294e599ef9decc24063a3
+SHA512:
+  metadata.gz: 892ac784c4fd58041b470056d862d1b0c8e57a31f889d4857cbedd27ad2af05b766dc9d3ab39b0de6798a174f23d683f7a90ec05c9271edc86ffc4ce0047c3d7
+  data.tar.gz: f65bf5a6b664b96078fda80e56b0cab90f9f61acc28331a1c235e015e62f66d7984de0716df9a1f551e36fc92d1e59202f33315226baafb9e699a89b562132d6

data/bin/rrinit

@@ -0,0 +1,184 @@
+#!/usr/bin/ruby
+
+require_relative "../lib/commons"
+
+args = CmdParser.setup(INIT_COMMAND, :hostname, :path) do |opts|
+    CmdParser.autoset_param "-pPORT",   "--port=PORT",    "Port of the remote host",                                :port,       [:propagate, :delete, :unlock, :status]
+    CmdParser.autoset_param "-uUSER",   "--user=USER",    "User of the remote host",                                :user,       [:propagate, :delete, :unlock, :status]
+    CmdParser.autoset_param "-nNETNS",  "--netns=NETNS",  "Network namespace",                                      :netns,      [:propagate, :delete, :unlock, :status]
+    CmdParser.autoset_param "-oOWNER",  "--owner=OWNER",  "Ownership of the files (defaults to the current user)",  :owner,      [:propagate, :delete, :unlock, :status]
+    
+    CmdParser.autoset_flag  "-r",       "--recursive",    "Ownership of the files (defaults to the current user)",  :recursive,  [:propagate]
+    CmdParser.autoset_flag  "-f",       "--force",        "Force the overwrite of existing data",                   :force
+    CmdParser.autoset_flag  "-R",       "--pull-only",    "Allows only the pull from the remote",                   :pullonly,   [:pushonly]
+    CmdParser.autoset_flag  "-W",       "--push-only",    "Allows only the push to the remote",                     :pushonly,   [:pullonly]    
+    
+    CmdParser.autoset_flag  "-D",       "--delete",       "Delete all the sync files (asks for confirmation)",      :delete,     [:propagate, :unlock, :status]
+    CmdParser.autoset_flag  "-p",       "--propagate",    "Propagate the root file to all the sub-directories",     :propagate,  [:delete, :unlock, :status]
+    CmdParser.autoset_flag  "-u",       "--unlock",       "Unlock all the remote information files",                :unlock,     [:delete, :propagate, :status]
+    CmdParser.autoset_flag  "-s",       "--status",       "Prints the status of the folder",                        :status,     [:delete, :propagate, :unlock]
+end
+
+if CmdParser.opt :delete
+    unless FileTest.exists? RemoteInfo.filename(".")
+        puts "This folder is not initialized yet. " + "Deletion aborted.".red
+        exit
+    end
+    
+    sub = CmdParser.opt(:recursive) ? " and its subdirectories" : ""
+    print "Are you sure you want to delete all the sync information in this directory#{sub}? [y/N] "
+    confirm = gets.chomp.downcase
+    if confirm != "y"
+        puts "Aborted.".red
+        exit
+    end
+    
+    print "Deleting all the remote files... "
+    puts "" if CmdParser.opt :verbose
+    FS.each_folder(".", CmdParser.opt(:recursive)) do |current|
+        vputs "Deleting remote information file for #{current}"
+        OS.remove_file RemoteInfo.filename(current)
+    end
+    
+    puts "Done!".green
+    exit
+    
+elsif CmdParser.opt :propagate
+    print "Propagating the remote information to all the subfolders... "
+    unless FileTest.exists? RemoteInfo.filename(".")
+        puts "\n" + "Error".red + ": Initialize this directory first. Aborting propagation."
+        exit
+    end
+    
+    rfile = RemoteInfo.load
+    
+    CmdParser.set :port, rfile.port
+    CmdParser.set :user, rfile.user
+    CmdParser.set :netns, rfile.netns
+    CmdParser.set :owner, rfile.owner
+    CmdParser.set :recursive, true
+    args[:hostname] = rfile.host
+    args[:path] = rfile.path
+    
+    vputs "\nPropagation information:"
+    vputs "\tHost: #{rfile.host}"
+    vputs "\tPath: #{rfile.path}"
+    vputs "\tPort: #{rfile.port}" if rfile.port
+    vputs "\tUser: #{rfile.user}" if rfile.user
+    vputs "\tNetwork namespace: #{rfile.netns}" if rfile.netns
+    vputs "\tOwner: #{rfile.owner}" if rfile.owner
+    #Does propagation through the normal procedure
+    
+elsif CmdParser.opt :unlock
+        print "Unlocking all the remote files... "
+        RemoteInfo.unlock_all current
+        puts "Done!".green
+        exit
+
+elsif CmdParser.opt :status
+    unless FileTest.exists? RemoteInfo.filename(".")
+        puts "This folder is not initialized yet."
+        exit
+    end
+    
+    rinfo = RemoteInfo.load "."
+    userstring = rinfo.user ? rinfo.user.to_s + "@" : ""
+    portstring = rinfo.port ? ":"+rinfo.port.to_s : ""
+    
+    mode = []
+    if rinfo.can_push?
+        mode.push "Push".green
+    else
+        mode.push "Push".red
+    end
+    
+    if rinfo.can_pull?
+        mode.push "Pull".green
+    else
+        mode.push "Pull".red
+    end
+    modestring = mode.join("|")
+    
+    puts "Root remote information:"
+    puts "\tHost: #{userstring}#{rinfo.host}#{portstring}"
+    puts "\tPath: #{rinfo.path}"
+    puts "\tNetwork namespace: #{rinfo.netns}" if rinfo.netns
+    puts "\tOwner: #{rinfo.owner}" if rinfo.owner
+    puts "\tMode: #{modestring}"
+    
+    puts "Local folders:"
+    ignore = []
+    FS.each_folder(".", true) do |current|
+        next if current == "."
+        
+        skip = false
+        ignore.each do |ig|
+            skip = true if current.start_with? ig
+        end
+        next if skip
+        
+        valid = File.join(rinfo.path, current)
+        
+        status = ""
+        if FileTest.exists? RemoteInfo.filename(current)
+            cinfo = RemoteInfo.load current
+            
+            if cinfo.path != valid || cinfo.host != rinfo.host
+                status = "DIFFERENT REMOTE".yellow  + "(" + ScpUtils.remote(nil, cinfo) + ")"
+                ignore.push current
+            else
+                status = "OK".green
+            end
+        else
+            status = "LOCAL ONLY".red
+            ignore.push current
+        end
+        puts "\t- #{current}: #{status}"
+    end
+    exit
+    
+end
+
+
+err = false
+unless args[:hostname]
+    puts "Error".red + ": You have to specify the remote hostname."
+    err = true
+end
+
+unless args[:path]
+    puts "Error".red + ": You have to specify the remote path."
+    err = true
+end
+
+if err
+    puts "Try #{INIT_COMMAND} -h to check how to use this command"
+    exit
+end
+
+unless CmdParser.opt :propagate
+    sub = CmdParser.opt(:recursive) ? " and its subdirectories" : ""
+    print "Initializing the directory#{sub}... "
+end
+
+FS.each_folder(".", CmdParser.opt(:recursive)) do |current|
+    if CmdParser.opt(:force) || !FileTest.exists?(RemoteInfo.filename(current))
+        rfile = RemoteInfo.new
+        rfile.port = CmdParser.opt :port
+        rfile.user = CmdParser.opt :user
+        rfile.netns = CmdParser.opt :netns
+        rfile.owner = CmdParser.opt :owner
+        rfile.operations = "w" if CmdParser.opt :pushonly
+        rfile.operations = "r" if CmdParser.opt :pullonly
+
+        rfile.host = args[:hostname]
+        rfile.path = (current != "." ? File.join(args[:path], current) : args[:path])
+        
+        vputs "Writing remote information for #{current}..."
+        rfile.save_info current
+    else
+        vputs "Skipping #{current} (already exists)..."
+    end
+end
+
+puts "Done!".green

data/bin/rrpull

@@ -0,0 +1,75 @@
+#!/usr/bin/ruby
+
+require_relative "../lib/commons"
+
+args = CmdParser.setup(PULL_COMMAND) do |opts|
+    CmdParser.autoset_param "-fFILE", "--file=FILE", "File to push", :file, [:directory]
+    CmdParser.autoset_param "-dDIR", "--directory=DIR", "Directory to push", :directory, [:file]
+    
+    CmdParser.autoset_param "-oOWNER", "--owner=OWNER", "Ownership of the files (defaults to the current user)", :owner
+end
+
+unless FileTest.exists? RemoteInfo.filename(".")
+    puts "Error".red + ": please, use #{INIT_COMMAND} before #{PULL_COMMAND}"
+    exit
+end
+
+remote_info    = RemoteInfo.load
+
+unless remote_info.can_pull?
+    puts "Error".red + ": pull forbidden (push-only directory). Aborted."
+    exit
+end
+
+isdir = !CmdParser.opt(:file)
+
+OS.run "mkdir -p \"#{CmdParser.opt(:directory)}\"" if CmdParser.opt(:directory)
+
+#Lock all the remote information files
+RemoteInfo.lock_all(CmdParser.opt(:directory) || ".", isdir) do
+    vputs "Locked all the remote information files in the path"
+    local   = ScpUtils.local CmdParser.opt(:file), CmdParser.opt(:directory)
+    remote  = ScpUtils.remote local, remote_info
+    remote = File.join(remote, ".")
+    
+    command = ScpUtils.scp remote, local, isdir, remote_info.port
+    
+    new_owner = CmdParser.opt(:owner) || remote_info.owner || OS.username
+    result = nil
+    if remote_info.netns
+        puts "Requiring root privileges to run in network namespace..."
+        result = OS.run "sudo ip netns exec #{remote_info.netns} #{command}"
+        new_owner = OS.username unless new_owner
+    else
+        result = OS.run command
+    end
+    
+    unless result
+        puts "An error occurred while executing the copy command. Exiting"
+        RemoteInfo.unlock_all
+        exit
+    end
+    
+    result[1].split("\n").each do |errline|
+        if errline.downcase.include?("permission denied") && !errline.downcase.include?(RemoteInfo::FILENAME)
+            puts "Error:" + errline
+        end
+    end
+    
+    if new_owner
+        puts "Requiring root privileges to change ownership..."
+        OS.run "sudo chown #{new_owner} \"#{local}\" #{isdir ? "-R" : ""}"
+    end
+    vputs "Unlocked all the remote information files in the path"
+end
+
+rinit_script = File.join File.expand_path(File.dirname(__FILE__)), INIT_COMMAND
+#Propagates the creation of remote file to all the new subfolders
+vputs "Calling #{INIT_COMMAND} to propagate the information..."
+result = OS.run "ruby \"#{rinit_script}\" -p"
+puts result[0]
+if result[1] != ""
+    puts "Error".red + ":" + result[1]
+end
+    
+puts "The local version is up to date.".green

data/bin/rrpush

@@ -0,0 +1,35 @@
+#!/usr/bin/ruby
+
+require_relative "../lib/commons"
+
+args = CmdParser.setup(PUSH_COMMAND) do |opts|
+    CmdParser.autoset_param "-fFILE", "--file=FILE", "File to push", :file, [:directory]
+    CmdParser.autoset_param "-dDIR", "--directory=DIR", "Directory to push", :directory, [:file]
+end
+
+unless FileTest.exists? RemoteInfo.filename(".")
+    puts "Error".red + ": please, use #{INIT_COMMAND} before #{PUSH_COMMAND}"
+    exit
+end
+
+remote_info    = RemoteInfo.load
+
+unless remote_info.can_push?
+    puts "Error".red + ": push forbidden (pull-only directory). Aborted."
+    exit
+end
+
+isdir   = !CmdParser.opt(:file)
+
+local   = ScpUtils.local CmdParser.opt(:file), CmdParser.opt(:directory)
+remote  = ScpUtils.remote local, remote_info
+
+command = ScpUtils.scp local, remote, isdir, remote_info.port
+if remote_info.netns
+    puts "Requiring root privileges to run in network namespace..."
+    OS.run "sudo ip netns exec #{remote_info.netns} #{command}"
+else
+    OS.run command
+end
+
+puts "The remote version is up to date.".green

data/lib/commons.rb

@@ -0,0 +1,284 @@
+require "optparse"
+require "open3"
+require "colorize"
+
+INIT_COMMAND = "rrinit"
+PUSH_COMMAND = "rrpush"
+PULL_COMMAND = "rrpull"
+
+class RemoteInfo
+    FILENAME = ".reminfo"
+    
+    attr_accessor   :host
+    attr_accessor   :port
+    attr_accessor   :user
+    attr_accessor   :path
+    attr_accessor   :netns
+    attr_accessor   :owner
+    attr_accessor   :operations
+    
+    def initialize
+        @netns = nil
+        @owner = nil
+        
+        @port = nil
+        @user = nil
+        
+        @operations = "rw"
+    end
+    
+    def self.load(folder=".")
+        rinfo = RemoteInfo.new
+        rinfo.read_info(folder)
+        return rinfo
+    end
+    
+    def self.filename(folder)
+        return File.join(folder, FILENAME)
+    end
+    
+    def can_pull?
+        return @operations.include? "r"
+    end
+    
+    def can_push?
+        return @operations.include? "w"
+    end
+    
+    def read_info(folder)
+        info = File.read(File.join(folder, FILENAME))
+        
+        rows = info.split "\n"
+        rows.each do |r|
+            key, value = *r.split("\t")
+            
+            key = key.strip
+            value = value.strip
+            
+            case key
+            when "host"
+                @host = value
+            when "port"
+                @port = value
+            when "user"
+                @user = value
+            when "path"
+                @path = value
+            when "netns"
+                @netns = value
+            when "owner"
+                @owner = value
+            when "operations"
+                @operations = value
+            end
+        end
+    end
+    
+    def save_info(to=".")
+        content = ""
+        content += "host\t#@host\n"
+        content += "port\t#@port\n"                 if @port
+        content += "user\t#@user\n"                 if @user
+        content += "path\t#@path\n"
+        content += "netns\t#@netns\n"               if @netns
+        content += "owner\t#@owner\n"               if @owner
+        content += "operations\t#@operations\n"
+        
+        dest = to ? File.join(to, FILENAME) : FILENAME
+        
+        File.write dest, content
+    end
+    
+    def self.unlock_all(local)
+        self.lock_all(local, true) {}
+    end
+    
+    def self.lock_all(local, prevent_write=true)
+         if (prevent_write)
+            FS.each_remote_info(local) do |rinfo|
+                OS.run "chmod -w \"#{rinfo}\""
+            end
+        end
+        
+        yield
+        
+        if (prevent_write)
+            FS.each_remote_info(local) do |rinfo|
+                OS.run "chmod +w \"#{rinfo}\""
+            end
+        end
+    end
+end
+
+class FS
+    def self.each_folder(dir, recursive=true)
+        queue = ["."]
+        visited = []
+        while queue.size > 0
+            current = queue.shift
+            
+            yield current
+            
+            if recursive
+                Dir.entries(current).each do |entry|
+                    next if [".",".."].include? entry
+                    to_queue = (current == "." ? entry : File.join(current, entry))
+                    
+                    queue.push to_queue if FileTest.directory? to_queue
+                end
+            end
+
+            queue -= visited
+            visited.push current
+        end
+    end
+    
+    def self.each_remote_info(dir)
+        self.each_folder(dir) do |folder|
+            filename = File.join(folder, RemoteInfo::FILENAME)
+            yield filename if FileTest.exists? filename
+        end
+    end
+end
+
+class ScpUtils
+    def self.remote(local, file)
+        user = file.user
+        port = file.port
+        host = file.host
+        path = file.path
+        
+        userstring = user ? user + "@" : ""
+        
+        remotepath = path
+        remotepath = File.join(remotepath, local) if local && local != "."
+        
+        result = "#{userstring}#{host}:#{remotepath}"
+    end
+    
+    def self.local(*candidates)
+        candidates.each do |c|
+            return c if c
+        end
+        
+        return "."
+    end
+    
+    def self.scp(from, to, dir, port=nil)
+        dirstring = dir ? "-r" : ""
+        portstring = port ? "-P " + port : ""
+        
+        return "scp #{portstring} #{dirstring} \"#{from}\" \"#{to}\""
+    end
+end
+
+class CmdParser
+    @@data = {}
+    @@bindings = {}
+    
+    def self.opt(key)
+        return @@data[key]
+    end
+    
+    def self.set(key, value)
+        @@data[key] = value
+    end
+    
+    def self.setup(cmd, *args)
+        parser = OptionParser.new do |opts|
+            opts.banner = "Usage: #{cmd} [options] #{args.join " "}"
+            
+            @@opts = opts
+            yield opts
+            @@opts = nil
+            
+            opts.on("-v", "--verbose", "Writes a lot of information") do
+                CmdParser.set :verbose, true
+            end
+            
+            opts.on("-h", "--help", "Prints this help") do
+                puts opts
+                exit
+            end
+        end
+        
+        parser.parse! ARGV
+        
+        arguments = {}
+        for i in 0...args.size
+            arguments[args[i]] = ARGV[i]
+        end
+        
+        return arguments
+    end
+    
+    def self.autoset_flag(short, long, description, flag, incompatibles=[])
+        @@bindings[flag] = short
+        @@opts.on(short, long, description) do
+            incompatibles.each do |incompatible|
+                CmdParser.assert_not_set incompatible, short, @@bindings[incompatible]
+            end
+            
+            CmdParser.set flag, true
+        end
+    end
+    
+    def self.autoset_param(short, long, description, flag, incompatibles=[])
+        @@bindings[flag] = short
+        @@opts.on(short, long, description) do |v|
+            incompatibles.each do |incompatible|
+                CmdParser.assert_not_set incompatible, short, @@bindings[incompatible]
+            end
+            
+            CmdParser.set flag, v
+        end
+    end
+    
+    def self.assert
+        error_message = yield
+        if error_message
+            puts error_message
+            exit
+        end
+    end
+    
+    def self.assert_not_set(forbidden_key, actual_param, forbidden_param, message="incompatible commands")
+        if CmdParser.opt(forbidden_key) != nil
+            puts "Do not use #{forbidden_param} with #{actual_param} (#{message}). Aborting."
+            exit
+        end
+    end
+end
+
+class ConsoleRunner
+    def remove_file(file)
+        File.unlink file
+    end
+    
+    def username
+        return `echo $USER`.chomp
+    end
+    
+    def run(cmd)
+        vputs "Executing command: #{cmd}"
+        stdout, stderr, status = Open3.capture3(cmd)
+        return [stdout, stderr, status]
+    end
+end
+
+class SimulatorRunner < ConsoleRunner
+    def remove_file(file)
+        puts "SIMULATE: removed #{file}"
+    end
+    
+    def run(cmd)
+        puts "SIMULATE: #{cmd}"
+    end
+end
+
+def vputs *args
+    puts *args if CmdParser.opt :verbose
+end
+
+OS = ConsoleRunner.new
+# OS = SimulatorRunner.new

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: remotesync
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Simone Scalabrino
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-01-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+description: Sync remote folders using ssh. Supports network namespaces in Linux.
+email: s.scalabrino9@gmail.com
+executables:
+- rrinit
+- rrpull
+- rrpush
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/rrinit
+- bin/rrpull
+- bin/rrpush
+- lib/commons.rb
+homepage: https://github.com/intersimone999/remotesync
+licenses:
+- GPL-3.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.3
+signing_key: 
+specification_version: 4
+summary: Sync remote folders using ssh
+test_files: []