Module: Autoproj::Ops

Defined in:
lib/autoproj/ops/build.rb,
lib/autoproj/ops/cache.rb,
lib/autoproj/ops/tools.rb,
lib/autoproj/ops/watch.rb,
lib/autoproj/ops/which.rb,
lib/autoproj/ops/import.rb,
lib/autoproj/ops/loader.rb,
lib/autoproj/ops/install.rb,
lib/autoproj/ops/snapshot.rb,
lib/autoproj/ops/cached_env.rb,
lib/autoproj/ops/atomic_write.rb,
lib/autoproj/ops/configuration.rb,
lib/autoproj/ops/phase_reporting.rb,
lib/autoproj/ops/main_config_switcher.rb more...

Defined Under Namespace

Modules: Tools Classes: Build, Cache, Configuration, Import, Install, Loader, MainConfigSwitcher, PackageSetHierarchy, PhaseReporting, Snapshot, WatchAlreadyRunning

Class Method Summary collapse

Class Method Details

.atomic_write(file_name, temp_dir = File.dirname(file_name)) ⇒ Object

Write to a file atomically. Useful for situations where you don’t want other processes or threads to see half-written files.

File.atomic_write('important.file') do |file|
  file.write('hello')
end

This method needs to create a temporary file. By default it will create it in the same directory as the destination file. If you don’t like this behavior you can provide a different directory but it must be on the same physical filesystem as the file you’re trying to write.

File.atomic_write('/data/something.important', '/data/tmp') do |file|
  file.write('hello')
end

Shamelessly stolen from ActiveSupport

[View source]

25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
 
# File 'lib/autoproj/ops/atomic_write.rb', line 25

def self.atomic_write(file_name, temp_dir = File.dirname(file_name))
    Tempfile.open(".#{File.basename(file_name)}", temp_dir) do |temp_file|
        temp_file.binmode
        yield temp_file
        temp_file.close

        old_stat = begin
            # Get original file permissions
            File.stat(file_name)
        rescue Errno::ENOENT
            # If not possible, probe which are the default permissions in the
            # destination directory.
            probe_stat_in(File.dirname(file_name))
        end

        if old_stat
            # Set correct permissions on new file
            begin
                File.chown(old_stat.uid, old_stat.gid, temp_file.path)
                # This operation will affect filesystem ACL's
                File.chmod(old_stat.mode, temp_file.path)
            rescue Errno::EPERM, Errno::EACCES
                # Changing file ownership failed, moving on.
            end
        end

        # Overwrite original file with temp file
        File.rename(temp_file.path, file_name)
    end
end

.cached_env_path(root_dir) ⇒ Object

[View source]

5
6
7
 
# File 'lib/autoproj/ops/cached_env.rb', line 5

def self.cached_env_path(root_dir)
    File.join(root_dir, ".autoproj", "env.yml")
end

.load_cached_env(root_dir) ⇒ Object

[View source]

9
10
11
12
13
14
15
16
17
 
# File 'lib/autoproj/ops/cached_env.rb', line 9

def self.load_cached_env(root_dir)
    path = cached_env_path(root_dir)
    if File.file?(path)
        env = YAML.safe_load(File.read(path))
        Autobuild::Environment::ExportedEnvironment.new(
            env["set"], env["unset"], env["update"]
        )
    end
end

.loader ⇒ Object

Deprecated.

use Autoproj.workspace, or better make sure all ops classes get their own workspace object as argument

[View source]

107
108
109
 
# File 'lib/autoproj/ops/loader.rb', line 107

def self.loader
    Autoproj.workspace
end

.probe_stat_in(dir) ⇒ Object

Private utility method.

[View source]

57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
 
# File 'lib/autoproj/ops/atomic_write.rb', line 57

def self.probe_stat_in(dir) # :nodoc:
    basename = [
        ".permissions_check",
        Thread.current.object_id,
        Process.pid,
        rand(1000000)
    ].join(".")

    file_name = File.join(dir, basename)
    FileUtils.touch(file_name)
    File.stat(file_name)
rescue Errno::ENOENT
    file_name = nil
ensure
    FileUtils.rm_f(file_name) if file_name
end

.save_cached_env(root_dir, env) ⇒ Object

[View source]

19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 
# File 'lib/autoproj/ops/cached_env.rb', line 19

def self.save_cached_env(root_dir, env)
    env = env.exported_environment
    path = cached_env_path(root_dir)
    existing =
        begin
            YAML.safe_load(File.read(path))
        rescue Exception
        end

    env = Hash["set" => env.set, "unset" => env.unset, "update" => env.update]
    if env != existing
        Ops.atomic_write(path) do |io|
            io.write YAML.dump(env)
        end
        true
    end
end

.watch_cleanup_marker(io) ⇒ Object

[View source]

32
33
34
35
 
# File 'lib/autoproj/ops/watch.rb', line 32

def self.watch_cleanup_marker(io)
    FileUtils.rm_f io.path
    io.close
end

.watch_create_marker(root_dir) ⇒ Object

[View source]

18
19
20
21
22
23
24
25
26
27
28
29
30
 
# File 'lib/autoproj/ops/watch.rb', line 18

def self.watch_create_marker(root_dir)
    io = File.open(watch_marker_path(root_dir), "a+")
    unless io.flock(File::LOCK_EX | File::LOCK_NB)
        raise WatchAlreadyRunning, "autoproj watch is already running as PID #{io.read.strip}"
    end

    io.truncate(0)
    io.puts Process.pid
    io.flush
rescue Exception
    io&.close
    raise
end

.watch_marker_path(root_dir) ⇒ Object

[View source]

3
4
5
 
# File 'lib/autoproj/ops/watch.rb', line 3

def self.watch_marker_path(root_dir)
    File.join(root_dir, ".autoproj", "watch")
end

.watch_running?(root_dir) ⇒ Boolean

Returns:

  • (Boolean)
[View source]

7
8
9
10
11
12
13
14
 
# File 'lib/autoproj/ops/watch.rb', line 7

def self.watch_running?(root_dir)
    io = File.open(watch_marker_path(root_dir))
    !io.flock(File::LOCK_EX | File::LOCK_NB)
rescue Errno::ENOENT
    false
ensure
    io&.close
end

.which(cmd, path_entries: nil) ⇒ String

Find the given executable file in PATH

If ‘cmd` is an absolute path, it will either return it or raise if `cmd` is not executable. Otherwise, looks for an executable named `cmd` in PATH and returns it, or raises if it cannot be found. The exception contains a more detailed reason for failure

Parameters:

  • cmd (String)

Returns:

  • (String) —

    the resolved program

Raises:

[View source]

19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
 
# File 'lib/autoproj/ops/which.rb', line 19

def self.which(cmd, path_entries: nil)
    path = Pathname.new(cmd)
    if path.absolute?
        if path.file? && path.executable?
            cmd
        elsif path.exist?
            raise ExecutableNotFound.new(cmd),
                  "given command `#{cmd}` exists but is not an executable file"
        else
            raise ExecutableNotFound.new(cmd),
                  "given command `#{cmd}` does not exist, "\
                  "an executable file was expected"
        end
    else
        path_entries = path_entries.call if path_entries.respond_to?(:call)
        absolute = Autobuild::Environment.find_executable_in_path(cmd, path_entries)

        if absolute
            absolute
        elsif (file = Autobuild::Environment.find_in_path(cmd, path_entries))
            raise ExecutableNotFound.new(cmd),
                  "`#{cmd}` resolves to #{file} which is not executable"
        else
            raise ExecutableNotFound.new(cmd),
                  "cannot resolve `#{cmd}` to an executable in the workspace"
        end
    end
end