lxd-common 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 031530f1093174e61e18c8a58e85805376bbc9b80368c800f7cc28cc3476e8ac
-  data.tar.gz: 0dea2d0bdb81700c0b0c05b990620fef2ae999b0828d1ddee0714e54a914909f
+  metadata.gz: 43d858bed713fa5394649fad875abd9cbf868cf572fb02599e3811e170f8f9fc
+  data.tar.gz: 47e0b0fb09991a4ef903a0ec4b2ddb89308a057e28923e7a5647f50247305ce9
 SHA512:
-  metadata.gz: 677d8545906f020bb8a485362cc39e8b7d809a96822fdeb05225d65f9da79bd1865c5105c3b3706946fc29ed09d3d0cbab4efb8c67c4acdd8724d6f41184f75f
-  data.tar.gz: 18772ed5c102a70bc3e0fdacb0742c7de807d210e339ba83d1db5efc61fc529e36ef423f364f630a3215564e99225b2771572d3699e231617fb2dbad3643f8a4
+  metadata.gz: f3840c037a9364eec153a4f9cc67ff4a4c81e0df0efa5f1fe6eb6e6d89e9c976ef69ba59386bd58e9c8510b79d51180fc37469a1e4c623d8fc2d55579dad5e7e
+  data.tar.gz: b0c51acca0425ccedf6285d9da0c616baf5b25c9c73de12855e8f4652d5331572b107b93b0dd7a73fe0db682bf49ae72c52fedc9f6cac8e868168d118a146cf1

data/lib/nexussw/lxd/rest_api.rb

@@ -54,12 +54,17 @@ module NexusSW
       end
 
       def write_file(container_name, path, options)
-        post "/1.0/containers/#{container_name}/files?path=#{path}", options[:content]
+        post "/1.0/containers/#{container_name}/files?path=#{path}", options[:content] do |req|
+          req.headers['Content-Type'] = 'application/octet-stream'
+          req.headers['X-LXD-uid'] = options[:uid] if options[:uid]
+          req.headers['X-LXD-gid'] = options[:gid] if options[:gid]
+          req.headers['X-LXD-mode'] = options[:file_mode] if options[:file_mode]
+        end
       end
 
-      def push_file(local_path, container_name, remote_path)
-        write_file container_name, remote_path, content: IO.binread(local_path)
-      end
+      # def push_file(local_path, container_name, remote_path)
+      #   write_file container_name, remote_path, content: IO.binread(local_path)
+      # end
 
       def pull_file(container_name, remote_path, local_path)
         IO.binwrite(local_path, read_file(container_name, remote_path))

data/lib/nexussw/lxd/rest_api/connection.rb

@@ -74,11 +74,8 @@ module NexusSW
             if content.is_a? Hash
               req.headers['Content-Type'] = 'application/json'
               req.body = content.to_json
-            elsif content # Only upon file upload
-              req.headers['Content-Type'] = 'application/octet-stream'
-              req.headers['X-LXD-uid'] = '0'
-              req.headers['X-LXD-gid'] = '0'
-              req.headers['X-LXD-mode'] = '0600'
+            elsif content # Only upon file upload at this time
+              yield req if block_given?
               req.body = content.to_s
             end
           end
@@ -87,7 +84,7 @@ module NexusSW
             case err['error_code']
             when 404 then raise RestAPI::Error::NotFound, err['error']
             when 400 then raise RestAPI::Error::BadRequest, err['error']
-            else raise "Error #{err['error_code']}: #{err['error']}"
+            else raise RestAPI::Error, "Error #{err['error_code']}: #{err['error']}"
             end
           end
           block_given? ? yield(response) : parse_response(response)

data/lib/nexussw/lxd/transport.rb

@@ -7,11 +7,15 @@ module NexusSW
         raise "#{self.class}#execute not implemented"
       end
 
+      def user(_user, _options = {})
+        raise "#{self.class}#user not implemented"
+      end
+
       def read_file(_path)
         raise "#{self.class}#read_file not implemented"
       end
 
-      def write_file(_path, _content)
+      def write_file(_path, _content, _options = {})
         raise "#{self.class}#write_file not implemented"
       end
 
@@ -19,11 +23,11 @@ module NexusSW
         raise "#{self.class}#download_file not implemented"
       end
 
-      def upload_file(_local_path, _path)
+      def upload_file(_local_path, _path, _options = {})
         raise "#{self.class}#upload_file not implemented"
       end
 
-      def upload_folder(_local_path, _path)
+      def upload_folder(_local_path, _path, _options = {})
         raise "#{self.class}#upload_folder not implemented"
       end
     end

data/lib/nexussw/lxd/transport/mixins/cli.rb

@@ -1,7 +1,8 @@
 require 'nexussw/lxd/transport/mixins/local'
+require 'nexussw/lxd/transport/mixins/helpers/users'
 require 'nexussw/lxd/transport/mixins/helpers/upload_folder'
 require 'tempfile'
-require 'pp'
+require 'shellwords'
 
 module NexusSW
   module LXD
@@ -18,17 +19,17 @@ module NexusSW
           attr_reader :inner_transport, :punt, :container_name, :config
 
           include Helpers::UploadFolder
+          include Helpers::UsersMixin
 
           def execute(command, options = {}, &block)
-            mycommand = command.is_a?(Array) ? command.join(' ') : command
+            command = runas_command(command, options) unless options[:subcommand]
+            command = command.shelljoin if command.is_a?(Array)
             subcommand = options[:subcommand] || "exec #{container_name} --"
-            mycommand = "lxc #{subcommand} #{mycommand}"
-            # options = options.except :subcommand if options.key? :subcommand
-            options = options.reject { |k, _| k == :subcommand }
-            # We would have competing timeout logic depending on who the inner transport is
-            # I'll just let rest & local do the timeouts, and if inner is a chef sourced transport, they have timeout logic of their own
-            # with_timeout_and_retries(options) do
-            inner_transport.execute mycommand, options, &block
+            command = "lxc #{subcommand} #{command}"
+
+            options.reject! { |k, _| [:subcommand, :runas].include? k }
+
+            inner_transport.execute command, options, &block
           end
 
           def read_file(path)
@@ -41,10 +42,12 @@ module NexusSW
             inner_transport.execute("rm -rf #{tfile}", capture: false) if tfile
           end
 
-          def write_file(path, content)
+          def write_file(path, content, options = {})
+            perms = file_perms(options)
+
             tfile = inner_mktmp
             inner_transport.write_file tfile, content
-            execute("#{tfile} #{container_name}#{path}", subcommand: 'file push', capture: false).error!
+            execute("#{tfile} #{container_name}#{path}", subcommand: "file push#{perms}", capture: false).error!
           ensure
             inner_transport.execute("rm -rf #{tfile}", capture: false) if tfile
           end
@@ -58,18 +61,22 @@ module NexusSW
             inner_transport.execute("rm -rf #{tfile}", capture: false) if tfile
           end
 
-          def upload_file(local_path, path)
+          def upload_file(local_path, path, options = {})
+            perms = file_perms(options)
+
             tfile = inner_mktmp if punt
             localname = tfile || local_path
             inner_transport.upload_file local_path, tfile if tfile
-            execute("#{localname} #{container_name}#{path}", subcommand: 'file push', capture: false).error!
+            execute("#{localname} #{container_name}#{path}", subcommand: "file push#{perms}", capture: false).error!
           ensure
             inner_transport.execute("rm -rf #{tfile}", capture: false) if tfile
           end
 
-          def upload_folder(local_path, path)
+          def upload_folder(local_path, path, options = {})
             return super unless config[:info] && config[:info]['api_extensions'] && config[:info]['api_extensions'].include?('directory_manipulation')
-            execute("-r #{local_path} #{container_name}#{path}", subcommand: 'file push', capture: false).error!
+
+            perms = file_perms(options)
+            execute("-r #{local_path} #{container_name}#{path}", subcommand: "file push#{perms}", capture: false).error!
           end
 
           def add_remote(host_name)
@@ -101,6 +108,15 @@ module NexusSW
           ensure
             tfile.unlink
           end
+
+          def file_perms(options = {})
+            perms = ''
+            perms += " --uid=#{options[:uid] || uid || 0}"
+            perms += " --gid=#{options[:gid] || gid || 0}"
+            fmode = options[:file_mode] || file_mode
+            perms += " --mode=#{fmode}" if fmode
+            perms
+          end
         end
       end
     end

data/lib/nexussw/lxd/transport/mixins/helpers/execute.rb

@@ -26,12 +26,14 @@ module NexusSW
               def error!
                 return self if exitstatus == 0
                 msg = "Error: '#{command}' failed with exit code #{exitstatus}.\n"
+                # msg += (" while running as '#{username}'.\n" if username) || ".\n"
                 msg += "STDOUT: #{stdout}" if stdout.is_a?(String) && !stdout.empty?
                 msg += "STDERR: #{stderr}" if stderr.is_a?(String) && !stderr.empty?
                 raise ::NexusSW::LXD::RestAPI::Error, msg
               end
             end
 
+            # LocalTransport does not have the users mixin, so code the `su` command on the rest & cli transports directly
             def execute(command, options = {}, &block)
               options ||= {}
               return execute_chunked(command, options) if options[:capture] == false && !block_given?

data/lib/nexussw/lxd/transport/mixins/helpers/upload_folder.rb

@@ -4,19 +4,19 @@ module NexusSW
       module Mixins
         module Helpers
           module UploadFolder
-            def upload_folder(local_path, path)
-              upload_using_tarball(local_path, path) || upload_files_individually(local_path, path)
+            def upload_folder(local_path, path, options = {})
+              upload_using_tarball(local_path, path, options) || upload_files_individually(local_path, path, options)
             end
 
-            def upload_files_individually(local_path, path)
+            def upload_files_individually(local_path, path, options = {})
               Dir.entries(local_path).map { |f| (f == '.' || f == '..') ? nil : File.join(local_path, f) }.compact.each do |f|
                 dest = File.join(path, File.basename(local_path))
-                upload_files_individually f, dest if File.directory? f
-                upload_file f, File.join(dest, File.basename(f)) if File.file? f
+                upload_files_individually f, dest, options if File.directory? f
+                upload_file f, File.join(dest, File.basename(f)), options if File.file? f
               end
             end
 
-            def upload_using_tarball(local_path, path)
+            def upload_using_tarball(local_path, path, options = {})
               return false unless can_archive?
               # TODO: should I return false upon error?  i.e. retry with individual file uploads if this fails?
               #   lets see how this does in the wild before deciding
@@ -32,12 +32,16 @@ module NexusSW
                   return false
                 end
                 fname = '/tmp/' + File.basename(tfile.path) + ".tar#{ext}"
-                upload_file tfile.path, fname
+                upload_file tfile.path, fname, options
                 # TODO: serious: make sure the tar extract does an overwrite of existing files
                 #   multiple converge support as well as CI cycle/dev updated files get updated instead of .1 suffixed (?)
                 #   I think I need a flag (it's been a while)
-                # TODO: explore the chmod & make the same as if uploaded via CLI
-                execute("bash -c 'mkdir -p #{path} && cd #{path} && tar -xf #{fname} && rm -rf #{fname} && chmod -R 600 #{File.basename(local_path)}'").error!
+                myuid = options[:uid] || uid || (0 if is_a?(Mixins::CLI))
+                mygid = options[:gid] || gid || (0 if is_a?(Mixins::CLI))
+                mymode = options[:file_mode] || file_mode
+                chown = " && chown -R #{myuid}:#{mygid} #{File.basename(local_path)}" if myuid
+                chmod = " && chmod -R #{mymode} #{File.basename(local_path)}" if mymode
+                execute("bash -c 'mkdir -p #{path} && cd #{path} && tar -xf #{fname} && rm -rf #{fname}#{chmod}#{chown}'").error!
               ensure
                 tfile.unlink
               end

data/lib/nexussw/lxd/transport/mixins/helpers/users.rb

@@ -0,0 +1,37 @@
+require 'shellwords'
+
+module NexusSW
+  module LXD
+    class Transport
+      module Mixins
+        module Helpers
+          module UsersMixin
+            def user(user_nameorid, options = {})
+              passwd = read_file options[:passwd_file] || '/etc/passwd'
+
+              # rework into .split(':') if this gets more complicated
+              @uid = user_nameorid.is_a?(String) ? passwd[/^#{user_nameorid}:[^:]*:([^:]*):/, 1] : user_nameorid
+              @username = user_nameorid.is_a?(String) ? user_nameorid : passwd[/^([^:]*):[^:]*:#{user_nameorid}:/, 1]
+
+              # gotcha: we're always setting the default group here, but it's changeable by the user, afterwards
+              # so if `user` gets called again, and the caller wants an alternative gid, the caller will need to re-set the gid
+              @gid = passwd[/^[^:]*:[^:]*:#{uid}:([^:]*):/, 1]
+            end
+
+            attr_accessor :file_mode, :gid
+            attr_reader :uid, :username
+
+            private
+
+            def runas_command(command, options = {})
+              uname = options[:runas] || username
+              return command unless uname
+              command = command.shelljoin if command.is_a? Array
+              ['su', uname, '-c', command]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nexussw/lxd/transport/mixins/rest.rb

@@ -1,8 +1,10 @@
 require 'nexussw/lxd/transport/mixins/helpers/execute'
+require 'nexussw/lxd/transport/mixins/helpers/users'
 require 'nexussw/lxd/transport/mixins/helpers/upload_folder'
 require 'nio/websocket'
 require 'tempfile'
 require 'json'
+require 'shellwords'
 
 module NexusSW
   module LXD
@@ -22,6 +24,7 @@ module NexusSW
 
           include Helpers::ExecuteMixin
           include Helpers::UploadFolder
+          include Helpers::UsersMixin
 
           class StdinStub
             # return self as an IO (un)like object
@@ -62,6 +65,7 @@ module NexusSW
             opid = nil
             backchannel = nil
             getlogs = false
+            command = runas_command(command, options)
             if block_given? && (options[:capture] || !config[:info][:api_extensions].include?('container_exec_recording'))
               apiopts = { :'wait-for-websocket' => true, interactive: false, sync: false }
               apiopts[:interactive] = true if options[:capture] == :interactive
@@ -114,17 +118,21 @@ module NexusSW
             api.read_file container_name, path
           end
 
-          def write_file(path, content)
-            api.write_file container_name, path, content: content
+          def write_file(path, content, options = {})
+            options = options.merge content: content
+            options[:uid] ||= uid if uid
+            options[:gid] ||= gid if gid
+            options[:file_mode] ||= file_mode if file_mode
+            api.write_file container_name, path, options
           end
 
           def download_file(path, local_path)
             api.pull_file container_name, path, local_path
           end
 
-          def upload_file(local_path, path)
+          def upload_file(local_path, path, options = {})
             # return api.push_file(local_path, container_name, path)
-            write_file(path, IO.binread(local_path))
+            write_file(path, IO.binread(local_path), options)
           end
 
           protected

data/lib/nexussw/lxd/version.rb

@@ -1,5 +1,5 @@
 module NexusSW
   module LXD
-    VERSION = '0.7.0'.freeze
+    VERSION = '0.8.0'.freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lxd-common
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Sean Zachariasen
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-01-15 00:00:00.000000000 Z
+date: 2018-01-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -127,6 +127,7 @@ files:
 - lib/nexussw/lxd/transport/mixins/cli.rb
 - lib/nexussw/lxd/transport/mixins/helpers/execute.rb
 - lib/nexussw/lxd/transport/mixins/helpers/upload_folder.rb
+- lib/nexussw/lxd/transport/mixins/helpers/users.rb
 - lib/nexussw/lxd/transport/mixins/local.rb
 - lib/nexussw/lxd/transport/mixins/rest.rb
 - lib/nexussw/lxd/transport/rest.rb