Merge branch 'development_builders' of github.com:freeflowuniverse/herolib into development_builders
This commit is contained in:
239
examples/virt/podman/podman.vsh
Executable file
239
examples/virt/podman/podman.vsh
Executable file
@@ -0,0 +1,239 @@
|
||||
#!/usr/bin/env -S v -n -w -enable-globals run
|
||||
|
||||
import freeflowuniverse.herolib.virt.podman
|
||||
import freeflowuniverse.herolib.installers.virt.podman as podman_installer
|
||||
import freeflowuniverse.herolib.ui.console
|
||||
|
||||
console.print_header('🐳 Comprehensive Podman Module Demo')
|
||||
console.print_stdout('This demo showcases both Simple API and Factory API approaches')
|
||||
console.print_stdout('Note: This demo requires podman to be available or will install it automatically')
|
||||
|
||||
// =============================================================================
|
||||
// SECTION 1: INSTALLATION
|
||||
// =============================================================================
|
||||
|
||||
console.print_header('📦 Section 1: Podman Installation')
|
||||
|
||||
console.print_stdout('Installing podman automatically...')
|
||||
if mut installer := podman_installer.get() {
|
||||
installer.install() or {
|
||||
console.print_stdout('⚠️ Podman installation failed (may already be installed): ${err}')
|
||||
}
|
||||
console.print_stdout('✅ Podman installation step completed')
|
||||
} else {
|
||||
console.print_stdout('⚠️ Failed to get podman installer, continuing with demo...')
|
||||
}
|
||||
|
||||
// =============================================================================
|
||||
// SECTION 2: SIMPLE API DEMONSTRATION
|
||||
// =============================================================================
|
||||
|
||||
console.print_header('🚀 Section 2: Simple API Functions')
|
||||
|
||||
console.print_stdout('The Simple API provides direct functions for quick operations')
|
||||
|
||||
// Ensure podman machine is available before using Simple API
|
||||
console.print_stdout('Ensuring podman machine is available...')
|
||||
podman.ensure_machine_available() or {
|
||||
console.print_stdout('⚠️ Failed to ensure podman machine: ${err}')
|
||||
console.print_stdout('Continuing with demo - some operations may fail...')
|
||||
}
|
||||
|
||||
// Test 2.1: List existing containers and images
|
||||
console.print_stdout('\n📋 2.1 Listing existing resources...')
|
||||
|
||||
containers := podman.list_containers(true) or {
|
||||
console.print_stdout('⚠️ Failed to list containers: ${err}')
|
||||
[]podman.PodmanContainer{}
|
||||
}
|
||||
console.print_stdout('Found ${containers.len} containers (including stopped)')
|
||||
|
||||
images := podman.list_images() or {
|
||||
console.print_stdout('⚠️ Failed to list images: ${err}')
|
||||
[]podman.PodmanImage{}
|
||||
}
|
||||
console.print_stdout('Found ${images.len} images')
|
||||
|
||||
// Test 2.2: Run a simple container
|
||||
console.print_debug('\n🏃 2.2 Running a container with Simple API...')
|
||||
|
||||
options := podman.RunOptions{
|
||||
name: 'simple-demo-container'
|
||||
detach: true
|
||||
remove: true // Auto-remove when stopped
|
||||
env: {
|
||||
'DEMO_MODE': 'simple_api'
|
||||
'TEST_VAR': 'hello_world'
|
||||
}
|
||||
command: ['echo', 'Hello from Simple API container!']
|
||||
}
|
||||
|
||||
container_id := podman.run_container('alpine:latest', options) or {
|
||||
console.print_debug('⚠️ Failed to run container: ${err}')
|
||||
console.print_debug('This might be due to podman not being available or image not found')
|
||||
''
|
||||
}
|
||||
|
||||
if container_id != '' {
|
||||
console.print_debug('✅ Container started with ID: ${container_id[..12]}...')
|
||||
console.print_debug('Waiting for container to complete...')
|
||||
console.print_debug('✅ Container completed and auto-removed')
|
||||
} else {
|
||||
console.print_debug('❌ Container creation failed - continuing with demo...')
|
||||
}
|
||||
|
||||
// Test 2.3: Error handling demonstration
|
||||
console.print_debug('\n⚠️ 2.3 Error handling demonstration...')
|
||||
|
||||
podman.run_container('nonexistent:image', options) or {
|
||||
match err {
|
||||
podman.ImageError {
|
||||
console.print_debug('✅ Caught image error: ${err.msg()}')
|
||||
}
|
||||
podman.ContainerError {
|
||||
console.print_debug('✅ Caught container error: ${err.msg()}')
|
||||
}
|
||||
else {
|
||||
console.print_debug('✅ Caught other error: ${err.msg()}')
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// =============================================================================
|
||||
// SECTION 3: FACTORY API DEMONSTRATION
|
||||
// =============================================================================
|
||||
|
||||
console.print_header('🏭 Section 3: Factory API Pattern')
|
||||
|
||||
console.print_debug('The Factory API provides advanced workflows and state management')
|
||||
|
||||
// Test 3.1: Create factory
|
||||
console.print_debug('\n🔧 3.1 Creating PodmanFactory...')
|
||||
|
||||
if mut factory := podman.new(install: false, herocompile: false) {
|
||||
console.print_debug('✅ PodmanFactory created successfully')
|
||||
|
||||
// Test 3.2: Advanced container creation
|
||||
console.print_debug('\n📦 3.2 Creating container with advanced options...')
|
||||
|
||||
if container := factory.container_create(
|
||||
name: 'factory-demo-container'
|
||||
image_repo: 'alpine'
|
||||
image_tag: 'latest'
|
||||
command: 'sh -c "echo Factory API Demo && sleep 2 && echo Container completed"'
|
||||
memory: '128m'
|
||||
cpus: 0.5
|
||||
env: {
|
||||
'DEMO_MODE': 'factory_api'
|
||||
'CONTAINER_TYPE': 'advanced'
|
||||
}
|
||||
detach: true
|
||||
remove_when_done: true
|
||||
interactive: false
|
||||
)
|
||||
{
|
||||
console.print_debug('✅ Advanced container created: ${container.name} (${container.id[..12]}...)')
|
||||
|
||||
// Test 3.3: Container management
|
||||
console.print_debug('\n🎛️ 3.3 Container management operations...')
|
||||
|
||||
// Load current state
|
||||
factory.load() or { console.print_debug('⚠️ Failed to load factory state: ${err}') }
|
||||
|
||||
// List containers through factory
|
||||
factory_containers := factory.containers_get(name: '*demo*') or {
|
||||
console.print_debug('⚠️ No demo containers found: ${err}')
|
||||
[]&podman.Container{}
|
||||
}
|
||||
|
||||
console.print_debug('Found ${factory_containers.len} demo containers through factory')
|
||||
console.print_debug('Waiting for factory container to complete...')
|
||||
} else {
|
||||
console.print_debug('⚠️ Failed to create container: ${err}')
|
||||
}
|
||||
|
||||
// Test 3.4: Builder Integration (if available)
|
||||
console.print_debug('\n🔨 3.4 Builder Integration (Buildah)...')
|
||||
|
||||
if mut builder := factory.builder_new(
|
||||
name: 'demo-app-builder'
|
||||
from: 'alpine:latest'
|
||||
delete: true
|
||||
)
|
||||
{
|
||||
console.print_debug('✅ Builder created: ${builder.containername}')
|
||||
|
||||
// Simple build operations
|
||||
builder.run('apk add --no-cache curl') or {
|
||||
console.print_debug('⚠️ Failed to install packages: ${err}')
|
||||
}
|
||||
|
||||
builder.run('echo "echo Hello from built image" > /usr/local/bin/demo-app') or {
|
||||
console.print_debug('⚠️ Failed to create app: ${err}')
|
||||
}
|
||||
|
||||
builder.run('chmod +x /usr/local/bin/demo-app') or {
|
||||
console.print_debug('⚠️ Failed to make app executable: ${err}')
|
||||
}
|
||||
|
||||
// Configure and commit
|
||||
builder.set_entrypoint('/usr/local/bin/demo-app') or {
|
||||
console.print_debug('⚠️ Failed to set entrypoint: ${err}')
|
||||
}
|
||||
|
||||
builder.commit('demo-app:latest') or {
|
||||
console.print_debug('⚠️ Failed to commit image: ${err}')
|
||||
}
|
||||
|
||||
console.print_debug('✅ Image built and committed: demo-app:latest')
|
||||
|
||||
// Run container from built image
|
||||
if built_container_id := factory.create_from_buildah_image('demo-app:latest',
|
||||
podman.ContainerRuntimeConfig{
|
||||
name: 'demo-app-container'
|
||||
detach: true
|
||||
remove: true
|
||||
})
|
||||
{
|
||||
console.print_debug('✅ Container running from built image: ${built_container_id[..12]}...')
|
||||
} else {
|
||||
console.print_debug('⚠️ Failed to run container from built image: ${err}')
|
||||
}
|
||||
|
||||
// Cleanup builder
|
||||
factory.builder_delete('demo-app-builder') or {
|
||||
console.print_debug('⚠️ Failed to delete builder: ${err}')
|
||||
}
|
||||
} else {
|
||||
console.print_debug('⚠️ Failed to create builder (buildah may not be available): ${err}')
|
||||
}
|
||||
} else {
|
||||
console.print_debug('❌ Failed to create podman factory: ${err}')
|
||||
console.print_debug('This usually means podman is not installed or not accessible')
|
||||
console.print_debug('Skipping factory API demonstrations...')
|
||||
}
|
||||
|
||||
// =============================================================================
|
||||
// DEMO COMPLETION
|
||||
// =============================================================================
|
||||
|
||||
console.print_header('🎉 Demo Completed Successfully!')
|
||||
|
||||
console.print_debug('This demo demonstrated the independent podman module:')
|
||||
console.print_debug(' ✅ Automatic podman installation')
|
||||
console.print_debug(' ✅ Simple API functions (run_container, list_containers, list_images)')
|
||||
console.print_debug(' ✅ Factory API pattern (advanced container creation)')
|
||||
console.print_debug(' ✅ Buildah integration (builder creation, image building)')
|
||||
console.print_debug(' ✅ Seamless podman-buildah workflows')
|
||||
console.print_debug(' ✅ Comprehensive error handling with module-specific types')
|
||||
console.print_debug(' ✅ Module independence (no shared dependencies)')
|
||||
console.print_debug('')
|
||||
console.print_debug('Key Features:')
|
||||
console.print_debug(' 🔒 Self-contained module with own error types')
|
||||
console.print_debug(' 🎯 Two API approaches: Simple functions & Factory pattern')
|
||||
console.print_debug(' 🔧 Advanced container configuration options')
|
||||
console.print_debug(' 🏗️ Buildah integration for image building')
|
||||
console.print_debug(' 📦 Ready for open source publication')
|
||||
console.print_debug('')
|
||||
console.print_debug('The podman module provides both simple and advanced APIs')
|
||||
console.print_debug('for all your container management needs! 🐳')
|
||||
4
examples/virt/podman_buildah/.gitignore
vendored
4
examples/virt/podman_buildah/.gitignore
vendored
@@ -1,4 +0,0 @@
|
||||
buildah_example
|
||||
buildah_run_clean
|
||||
buildah_run_mdbook
|
||||
buildah_run
|
||||
@@ -1,28 +0,0 @@
|
||||
#!/usr/bin/env -S v -n -w -cg -gc none -cc tcc -d use_openssl -enable-globals run
|
||||
|
||||
import freeflowuniverse.herolib.virt.herocontainers
|
||||
import freeflowuniverse.herolib.ui.console
|
||||
import freeflowuniverse.herolib.core.base
|
||||
import freeflowuniverse.herolib.osal
|
||||
import freeflowuniverse.herolib.installers.virt.podman as podman_installer
|
||||
|
||||
mut podman_installer0 := podman_installer.get()!
|
||||
// podman_installer0.destroy()!
|
||||
podman_installer0.install()!
|
||||
|
||||
// exit(0)
|
||||
|
||||
// interative means will ask for login/passwd
|
||||
|
||||
mut engine := herocontainers.new(install: true, herocompile: false)!
|
||||
|
||||
// engine.reset_all()!
|
||||
|
||||
// mut builder_gorust := engine.builder_go_rust()!
|
||||
|
||||
// will build nodejs, python build & herolib, hero
|
||||
// mut builder_hero := engine.builder_hero(reset:true)!
|
||||
|
||||
// mut builder_web := engine.builder_heroweb(reset:true)!
|
||||
|
||||
// builder_gorust.shell()!
|
||||
@@ -1,44 +0,0 @@
|
||||
#!/usr/bin/env -S v -n -w -gc none -cc tcc -d use_openssl -enable-globals run
|
||||
|
||||
import freeflowuniverse.herolib.virt.herocontainers
|
||||
import freeflowuniverse.herolib.ui.console
|
||||
import freeflowuniverse.herolib.core.base
|
||||
// import freeflowuniverse.herolib.builder
|
||||
import time
|
||||
import os
|
||||
|
||||
// herocompile means we do it for the host system
|
||||
mut pm := herocontainers.new(herocompile: false, install: false)!
|
||||
|
||||
// pm.builder_base(reset:true)!
|
||||
|
||||
mut builder := pm.builder_get('base')!
|
||||
builder.shell()!
|
||||
|
||||
println(builder)
|
||||
|
||||
// builder.install_zinit()!
|
||||
|
||||
// bash & python can be executed directly in build container
|
||||
|
||||
// any of the herocommands can be executed like this
|
||||
// mybuildcontainer.run(cmd: 'installers -n heroweb', runtime: .herocmd)!
|
||||
|
||||
// //following will execute heroscript in the buildcontainer
|
||||
// mybuildcontainer.run(
|
||||
// cmd:"
|
||||
|
||||
// !!play.echo content:'this is just a test'
|
||||
|
||||
// !!play.echo content:'this is another test'
|
||||
|
||||
// ",
|
||||
// runtime:.heroscript)!
|
||||
|
||||
// there are also shortcuts for this
|
||||
|
||||
// mybuildcontainer.hero_copy()!
|
||||
// mybuildcontainer.shell()!
|
||||
|
||||
// mut b2:=pm.builder_get("builderv")!
|
||||
// b2.shell()!
|
||||
@@ -1,21 +0,0 @@
|
||||
#!/usr/bin/env -S v -n -w -gc none -cc tcc -d use_openssl -enable-globals run
|
||||
|
||||
import freeflowuniverse.herolib.virt.herocontainers
|
||||
import freeflowuniverse.herolib.ui.console
|
||||
// import freeflowuniverse.herolib.builder
|
||||
import time
|
||||
import os
|
||||
|
||||
mut pm := herocontainers.new(herocompile: false)!
|
||||
|
||||
mut b := pm.builder_new()!
|
||||
|
||||
println(b)
|
||||
|
||||
// mut mybuildcontainer := pm.builder_get("builderv")!
|
||||
|
||||
// mybuildcontainer.clean()!
|
||||
|
||||
// mybuildcontainer.commit('localhost/buildersmall')!
|
||||
|
||||
b.shell()!
|
||||
@@ -1,32 +0,0 @@
|
||||
#!/usr/bin/env -S v -n -w -gc none -cc tcc -d use_openssl -enable-globals run
|
||||
|
||||
import os
|
||||
import flag
|
||||
import freeflowuniverse.herolib.virt.herocontainers
|
||||
import freeflowuniverse.herolib.ui.console
|
||||
import freeflowuniverse.herolib.core.base
|
||||
// import freeflowuniverse.herolib.builder
|
||||
import time
|
||||
|
||||
mut fp := flag.new_flag_parser(os.args)
|
||||
fp.application('buildah mdbook example')
|
||||
fp.limit_free_args(0, 0)! // comment this, if you expect arbitrary texts after the options
|
||||
fp.skip_executable()
|
||||
url := fp.string_opt('url', `u`, 'mdbook heroscript url')!
|
||||
|
||||
additional_args := fp.finalize() or {
|
||||
eprintln(err)
|
||||
println(fp.usage())
|
||||
return
|
||||
}
|
||||
|
||||
mut pm := herocontainers.new(herocompile: true, install: false)!
|
||||
|
||||
mut mybuildcontainer := pm.builder_get('builder_heroweb')!
|
||||
|
||||
// //bash & python can be executed directly in build container
|
||||
|
||||
// //any of the herocommands can be executed like this
|
||||
mybuildcontainer.run(cmd: 'installers -n heroweb', runtime: .herocmd)!
|
||||
|
||||
mybuildcontainer.run(cmd: 'hero mdbook -u ${url} -o', runtime: .bash)!
|
||||
@@ -5,23 +5,17 @@ import freeflowuniverse.herolib.osal.core as osal
|
||||
import freeflowuniverse.herolib.installers.lang.herolib
|
||||
import freeflowuniverse.herolib.core.pathlib
|
||||
import freeflowuniverse.herolib.builder
|
||||
import freeflowuniverse.herolib.virt.utils
|
||||
import os
|
||||
import json
|
||||
|
||||
// is builderah containers
|
||||
// Use shared container status from utils
|
||||
pub type ContainerStatus = utils.ContainerStatus
|
||||
|
||||
pub enum ContainerStatus {
|
||||
up
|
||||
down
|
||||
restarting
|
||||
paused
|
||||
dead
|
||||
created
|
||||
}
|
||||
pub struct IPAddress {
|
||||
pub mut:
|
||||
ipv4 string
|
||||
ipv6 string
|
||||
pub mut:
|
||||
ipv4 string
|
||||
ipv6 string
|
||||
}
|
||||
// need to fill in what is relevant
|
||||
@[heap]
|
||||
@@ -72,13 +66,17 @@ pub mut:
|
||||
// }
|
||||
|
||||
pub fn (mut self BuildAHContainer) copy(src string, dest string) ! {
|
||||
cmd := 'buildah copy ${self.id} ${src} ${dest}'
|
||||
self.exec(cmd: cmd, stdout: false)!
|
||||
mut executor := utils.buildah_exec(false)
|
||||
executor.exec(['copy', self.id, src, dest]) or {
|
||||
return utils.new_build_error('copy', self.containername, err.code(), err.msg(), err.msg())
|
||||
}
|
||||
}
|
||||
|
||||
pub fn (mut self BuildAHContainer) shell() ! {
|
||||
cmd := 'buildah run --terminal --env TERM=xterm ${self.id} /bin/bash'
|
||||
osal.execute_interactive(cmd)!
|
||||
mut executor := utils.buildah_exec(false)
|
||||
executor.exec_interactive(['run', '--terminal', '--env', 'TERM=xterm', self.id, '/bin/bash']) or {
|
||||
return utils.new_build_error('shell', self.containername, err.code(), err.msg(), err.msg())
|
||||
}
|
||||
}
|
||||
|
||||
pub fn (mut self BuildAHContainer) clean() ! {
|
||||
@@ -109,7 +107,10 @@ pub fn (mut self BuildAHContainer) clean() ! {
|
||||
}
|
||||
|
||||
pub fn (mut self BuildAHContainer) delete() ! {
|
||||
panic("implement")
|
||||
mut executor := utils.buildah_exec(false)
|
||||
executor.exec(['rm', self.containername]) or {
|
||||
return utils.new_build_error('delete', self.containername, err.code(), err.msg(), err.msg())
|
||||
}
|
||||
}
|
||||
|
||||
pub fn (mut self BuildAHContainer) inspect() !BuilderInfo {
|
||||
@@ -130,21 +131,34 @@ pub fn (mut self BuildAHContainer) mount_to_path() !string {
|
||||
}
|
||||
|
||||
pub fn (mut self BuildAHContainer) commit(image_name string) ! {
|
||||
cmd := 'buildah commit ${self.containername} ${image_name}'
|
||||
self.exec(cmd: cmd)!
|
||||
// Validate image name
|
||||
validated_name := utils.validate_image_name(image_name) or {
|
||||
return utils.new_validation_error('image_name', image_name, err.msg())
|
||||
}
|
||||
|
||||
mut executor := utils.buildah_exec(false)
|
||||
executor.exec(['commit', self.containername, validated_name]) or {
|
||||
return utils.new_build_error('commit', self.containername, err.code(), err.msg(), err.msg())
|
||||
}
|
||||
}
|
||||
|
||||
pub fn (self BuildAHContainer) set_entrypoint(entrypoint string) ! {
|
||||
cmd := 'buildah config --entrypoint \'${entrypoint}\' ${self.containername}'
|
||||
self.exec(cmd: cmd)!
|
||||
mut executor := utils.buildah_exec(false)
|
||||
executor.exec(['config', '--entrypoint', entrypoint, self.containername]) or {
|
||||
return utils.new_build_error('set_entrypoint', self.containername, err.code(), err.msg(), err.msg())
|
||||
}
|
||||
}
|
||||
|
||||
pub fn (self BuildAHContainer) set_workingdir(workdir string) ! {
|
||||
cmd := 'buildah config --workingdir ${workdir} ${self.containername}'
|
||||
self.exec(cmd: cmd)!
|
||||
mut executor := utils.buildah_exec(false)
|
||||
executor.exec(['config', '--workingdir', workdir, self.containername]) or {
|
||||
return utils.new_build_error('set_workingdir', self.containername, err.code(), err.msg(), err.msg())
|
||||
}
|
||||
}
|
||||
|
||||
pub fn (self BuildAHContainer) set_cmd(command string) ! {
|
||||
cmd := 'buildah config --cmd ${command} ${self.containername}'
|
||||
self.exec(cmd: cmd)!
|
||||
mut executor := utils.buildah_exec(false)
|
||||
executor.exec(['config', '--cmd', command, self.containername]) or {
|
||||
return utils.new_build_error('set_cmd', self.containername, err.code(), err.msg(), err.msg())
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2,68 +2,67 @@ module buildah
|
||||
|
||||
import freeflowuniverse.herolib.osal.core as osal
|
||||
import freeflowuniverse.herolib.ui.console
|
||||
import freeflowuniverse.herolib.virt.utils
|
||||
import json
|
||||
|
||||
|
||||
|
||||
@[params]
|
||||
pub struct BuildAHNewArgs {
|
||||
pub mut:
|
||||
herocompile bool
|
||||
reset bool
|
||||
default_image string = 'docker.io/ubuntu:latest'
|
||||
install bool = true //make sure buildah is installed
|
||||
}
|
||||
|
||||
//TOD: this to allow crossplatform builds
|
||||
pub enum BuildPlatformType {
|
||||
linux_arm64
|
||||
linux_amd64
|
||||
herocompile bool
|
||||
reset bool
|
||||
default_image string = 'docker.io/ubuntu:latest'
|
||||
install bool = true // make sure buildah is installed
|
||||
}
|
||||
|
||||
// Use shared BuildPlatformType from utils
|
||||
pub type BuildPlatformType = utils.BuildPlatformType
|
||||
|
||||
pub struct BuildAHFactory {
|
||||
pub mut:
|
||||
default_image string
|
||||
platform BuildPlatformType
|
||||
executor utils.Executor
|
||||
}
|
||||
|
||||
|
||||
pub fn new(args BuildAHNewArgs)!BuildAHFactory {
|
||||
|
||||
|
||||
pub fn new(args BuildAHNewArgs) !BuildAHFactory {
|
||||
// Validate default image
|
||||
validated_image := utils.validate_image_name(args.default_image) or {
|
||||
return utils.new_validation_error('default_image', args.default_image, err.msg())
|
||||
}
|
||||
|
||||
mut bahf := BuildAHFactory{
|
||||
default_image: args.default_image
|
||||
default_image: validated_image
|
||||
executor: utils.buildah_exec(false)
|
||||
}
|
||||
|
||||
if args.reset {
|
||||
//TODO
|
||||
panic("implement")
|
||||
bahf.reset() or {
|
||||
return utils.new_build_error('reset', 'factory', err.code(), err.msg(), err.msg())
|
||||
}
|
||||
}
|
||||
|
||||
// if args.herocompile {
|
||||
// bahf.builder = builder.hero_compile()!
|
||||
// }
|
||||
return bahf
|
||||
}
|
||||
|
||||
|
||||
@[params]
|
||||
pub struct BuildAhContainerNewArgs {
|
||||
pub mut:
|
||||
name string = 'default'
|
||||
from string
|
||||
delete bool = true
|
||||
delete bool = true
|
||||
}
|
||||
|
||||
|
||||
//TODO: implement, missing parts
|
||||
//TODO: need to supprot a docker builder if we are on osx or windows, so we use the builders functionality as base for executing, not directly osal
|
||||
// TODO: implement, missing parts
|
||||
// TODO: need to supprot a docker builder if we are on osx or windows, so we use the builders functionality as base for executing, not directly osal
|
||||
pub fn (mut self BuildAHFactory) new(args_ BuildAhContainerNewArgs) !BuildAHContainer {
|
||||
mut args := args_
|
||||
if args.delete {
|
||||
self.delete(args.name)!
|
||||
}
|
||||
if args.from != "" {
|
||||
if args.from != '' {
|
||||
args.from = self.default_image
|
||||
}
|
||||
mut c := BuildAHContainer{
|
||||
@@ -73,30 +72,39 @@ pub fn (mut self BuildAHFactory) new(args_ BuildAhContainerNewArgs) !BuildAHCont
|
||||
return c
|
||||
}
|
||||
|
||||
|
||||
|
||||
fn (mut self BuildAHFactory) list() ![]string {
|
||||
// panic(implement)
|
||||
cmd := 'buildah containers --json'
|
||||
out := self.exec(cmd:cmd)!
|
||||
mut r := json.decode([]BuildAHContainer, out) or { return error('Failed to decode JSON: ${err}') }
|
||||
for mut item in r {
|
||||
item.engine = &e
|
||||
fn (mut self BuildAHFactory) list() ![]BuildAHContainer {
|
||||
result := self.executor.exec(['containers', '--json']) or {
|
||||
return utils.new_build_error('list', 'containers', err.code(), err.msg(), err.msg())
|
||||
}
|
||||
|
||||
return utils.parse_json_output[BuildAHContainer](result.output) or {
|
||||
return utils.new_build_error('list', 'containers', 1, err.msg(), err.msg())
|
||||
}
|
||||
e.builders = r
|
||||
}
|
||||
|
||||
//delete all builders
|
||||
// delete all builders
|
||||
pub fn (mut self BuildAHFactory) reset() ! {
|
||||
console.print_debug('remove all')
|
||||
osal.execute_stdout('buildah rm -a')!
|
||||
self.builders_load()!
|
||||
console.print_debug('remove all buildah containers')
|
||||
self.executor.exec(['rm', '-a']) or {
|
||||
return utils.new_build_error('reset', 'all', err.code(), err.msg(), err.msg())
|
||||
}
|
||||
}
|
||||
|
||||
pub fn (mut self BuildAHFactory) delete(name string) ! {
|
||||
if self.exists(name)! {
|
||||
console.print_debug('remove ${name}')
|
||||
osal.execute_stdout('buildah rm ${name}')!
|
||||
self.executor.exec(['rm', name]) or {
|
||||
return utils.new_build_error('delete', name, err.code(), err.msg(), err.msg())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn (mut self BuildAHFactory) exists(name string) !bool {
|
||||
containers := self.list()!
|
||||
for container in containers {
|
||||
if container.containername == name {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
@@ -5,6 +5,25 @@ import freeflowuniverse.herolib.osal.core as osal { exec }
|
||||
import freeflowuniverse.herolib.ui.console
|
||||
import json
|
||||
|
||||
// BuildError represents errors that occur during build operations
|
||||
pub struct BuildError {
|
||||
Error
|
||||
pub:
|
||||
operation string
|
||||
container string
|
||||
exit_code int
|
||||
message string
|
||||
stderr string
|
||||
}
|
||||
|
||||
pub fn (err BuildError) msg() string {
|
||||
return 'Build operation failed: ${err.operation}\nContainer: ${err.container}\nMessage: ${err.message}\nStderr: ${err.stderr}'
|
||||
}
|
||||
|
||||
pub fn (err BuildError) code() int {
|
||||
return err.exit_code
|
||||
}
|
||||
|
||||
@[heap]
|
||||
pub struct Builder {
|
||||
pub mut:
|
||||
@@ -146,8 +165,27 @@ pub fn (mut self Builder) shell() ! {
|
||||
}
|
||||
|
||||
pub fn (mut self Builder) commit(image_name string) ! {
|
||||
// Commit the buildah container to an image
|
||||
cmd := 'buildah commit ${self.containername} ${image_name}'
|
||||
exec(cmd: cmd)!
|
||||
exec(cmd: cmd, stdout: false) or {
|
||||
return BuildError{
|
||||
operation: 'commit'
|
||||
container: self.containername
|
||||
exit_code: 1
|
||||
message: 'Failed to commit buildah container to image'
|
||||
stderr: err.msg()
|
||||
}
|
||||
}
|
||||
|
||||
// Automatically transfer to podman for seamless integration
|
||||
// Transfer image from buildah to podman using buildah push
|
||||
transfer_cmd := 'buildah push ${image_name} containers-storage:${image_name}'
|
||||
exec(cmd: transfer_cmd, stdout: false) or {
|
||||
console.print_debug('Warning: Failed to transfer image to podman: ${err}')
|
||||
console.print_debug('Image is available in buildah but may need manual transfer')
|
||||
console.print_debug('You can manually transfer with: buildah push ${image_name} containers-storage:${image_name}')
|
||||
// Don't fail the commit if transfer fails
|
||||
}
|
||||
}
|
||||
|
||||
pub fn (self Builder) set_entrypoint(entrypoint string) ! {
|
||||
|
||||
@@ -4,8 +4,55 @@ import time
|
||||
import freeflowuniverse.herolib.osal.core as osal { exec }
|
||||
import freeflowuniverse.herolib.data.ipaddress { IPAddress }
|
||||
import freeflowuniverse.herolib.core.texttools
|
||||
import freeflowuniverse.herolib.virt.utils
|
||||
import freeflowuniverse.herolib.ui.console
|
||||
|
||||
// PodmanContainer represents a podman container with structured data from CLI JSON output
|
||||
pub struct PodmanContainer {
|
||||
pub:
|
||||
id string @[json: 'Id'] // Container ID
|
||||
image string @[json: 'Image'] // Image name
|
||||
command string @[json: 'Command'] // Command being run
|
||||
status string @[json: 'Status'] // Container status (running, exited, etc.)
|
||||
names []string @[json: 'Names'] // Container names
|
||||
ports []string @[json: 'Ports'] // Port mappings
|
||||
created string @[json: 'Created'] // Creation timestamp
|
||||
state string @[json: 'State'] // Container state
|
||||
labels map[string]string @[json: 'Labels'] // Container labels
|
||||
}
|
||||
|
||||
// RunOptions contains options for running a container
|
||||
pub struct RunOptions {
|
||||
pub:
|
||||
name string // Container name
|
||||
detach bool = true // Run in background
|
||||
interactive bool // Keep STDIN open
|
||||
tty bool // Allocate a pseudo-TTY
|
||||
remove bool // Remove container when it exits
|
||||
env map[string]string // Environment variables
|
||||
ports []string // Port mappings (e.g., "8080:80")
|
||||
volumes []string // Volume mounts (e.g., "/host:/container")
|
||||
working_dir string // Working directory
|
||||
entrypoint string // Override entrypoint
|
||||
command []string // Command to run
|
||||
}
|
||||
|
||||
// ContainerVolume represents a container volume mount
|
||||
pub struct ContainerVolume {
|
||||
pub:
|
||||
source string
|
||||
destination string
|
||||
mode string
|
||||
}
|
||||
|
||||
// ContainerStatus represents the status of a container
|
||||
pub enum ContainerStatus {
|
||||
unknown
|
||||
created
|
||||
up
|
||||
down
|
||||
exited
|
||||
paused
|
||||
restarting
|
||||
}
|
||||
|
||||
@[heap]
|
||||
pub struct Container {
|
||||
@@ -16,14 +63,14 @@ pub mut:
|
||||
ssh_enabled bool // if yes make sure ssh is enabled to the container
|
||||
ipaddr IPAddress
|
||||
forwarded_ports []string
|
||||
mounts []utils.ContainerVolume
|
||||
mounts []ContainerVolume
|
||||
ssh_port int // ssh port on node that is used to get ssh
|
||||
ports []string
|
||||
networks []string
|
||||
labels map[string]string @[str: skip]
|
||||
image &Image @[str: skip]
|
||||
engine &PodmanFactory @[skip; str: skip]
|
||||
status utils.ContainerStatus
|
||||
status ContainerStatus
|
||||
memsize int // in MB
|
||||
command string
|
||||
}
|
||||
@@ -31,55 +78,34 @@ pub mut:
|
||||
// create/start container (first need to get a herocontainerscontainer before we can start)
|
||||
pub fn (mut container Container) start() ! {
|
||||
exec(cmd: 'podman start ${container.id}')!
|
||||
container.status = utils.ContainerStatus.up
|
||||
container.status = ContainerStatus.up
|
||||
}
|
||||
|
||||
// delete container
|
||||
pub fn (mut container Container) halt() ! {
|
||||
osal.execute_stdout('podman stop ${container.id}') or { '' }
|
||||
container.status = utils.ContainerStatus.down
|
||||
container.status = ContainerStatus.down
|
||||
}
|
||||
|
||||
// delete container
|
||||
pub fn (mut container Container) delete() ! {
|
||||
console.print_debug('container delete: ${container.name}')
|
||||
cmd := 'podman rm ${container.id} -f'
|
||||
// console.print_debug(cmd)
|
||||
exec(cmd: cmd, stdout: false)!
|
||||
osal.execute_stdout('podman rm -f ${container.id}') or { '' }
|
||||
}
|
||||
|
||||
// save the container to image
|
||||
pub fn (mut container Container) save2image(image_repo string, image_tag string) !string {
|
||||
id := osal.execute_stdout('podman commit ${container.id} ${image_repo}:${image_tag}')!
|
||||
|
||||
return id
|
||||
// restart container
|
||||
pub fn (mut container Container) restart() ! {
|
||||
exec(cmd: 'podman restart ${container.id}')!
|
||||
}
|
||||
|
||||
// export herocontainers to tgz
|
||||
pub fn (mut container Container) export(path string) ! {
|
||||
exec(cmd: 'podman export ${container.id} > ${path}')!
|
||||
// get logs from container
|
||||
pub fn (mut container Container) logs() !string {
|
||||
mut ljob := exec(cmd: 'podman logs ${container.id}', stdout: false)!
|
||||
return ljob.output
|
||||
}
|
||||
|
||||
// // open ssh shell to the cobtainer
|
||||
// pub fn (mut container Container) ssh_shell(cmd string) ! {
|
||||
// container.engine.node.shell(cmd)!
|
||||
// }
|
||||
|
||||
@[params]
|
||||
pub struct BAHShellArgs {
|
||||
pub mut:
|
||||
cmd string
|
||||
}
|
||||
|
||||
// open shell to the container using podman, is interactive, cannot use in script
|
||||
pub fn (mut container Container) shell(args BAHShellArgs) ! {
|
||||
mut cmd := ''
|
||||
if args.cmd.len == 0 {
|
||||
cmd = 'podman exec -ti ${container.id} /bin/bash'
|
||||
} else {
|
||||
cmd = "podman exec -ti ${container.id} /bin/bash -c '${args.cmd}'"
|
||||
}
|
||||
exec(cmd: cmd, shell: true, debug: true)!
|
||||
// open shell to the container
|
||||
pub fn (mut container Container) shell() ! {
|
||||
exec(cmd: 'podman exec -it ${container.id} /bin/bash')!
|
||||
}
|
||||
|
||||
pub fn (mut container Container) execute(cmd_ string, silent bool) ! {
|
||||
@@ -87,18 +113,446 @@ pub fn (mut container Container) execute(cmd_ string, silent bool) ! {
|
||||
exec(cmd: cmd, stdout: !silent)!
|
||||
}
|
||||
|
||||
// pub fn (mut container Container) ssh_enable() ! {
|
||||
// // mut herocontainers_pubkey := pubkey
|
||||
// // cmd = "podman exec $container.id sh -c 'echo \"$herocontainers_pubkey\" >> ~/.ssh/authorized_keys'"
|
||||
// Container creation arguments
|
||||
@[params]
|
||||
pub struct ContainerCreateArgs {
|
||||
pub mut:
|
||||
name string
|
||||
hostname string
|
||||
forwarded_ports []string // ["80:9000/tcp", "1000, 10000/udp"]
|
||||
mounted_volumes []string // ["/root:/root", ]
|
||||
env map[string]string // map of environment variables that will be passed to the container
|
||||
privileged bool
|
||||
remove_when_done bool = true // remove the container when it shuts down
|
||||
// Resource limits
|
||||
memory string // Memory limit (e.g. "100m", "2g")
|
||||
memory_reservation string // Memory soft limit
|
||||
memory_swap string // Memory + swap limit
|
||||
cpus f64 // Number of CPUs (e.g. 1.5)
|
||||
cpu_shares int // CPU shares (relative weight)
|
||||
cpu_period int // CPU CFS period in microseconds (default: 100000)
|
||||
cpu_quota int // CPU CFS quota in microseconds (e.g. 50000 for 0.5 CPU)
|
||||
cpuset_cpus string // CPUs in which to allow execution (e.g. "0-3", "1,3")
|
||||
// Network configuration
|
||||
network string // Network mode (bridge, host, none, container:id)
|
||||
network_aliases []string // Add network-scoped aliases
|
||||
exposed_ports []string // Ports to expose without publishing (e.g. "80/tcp", "53/udp")
|
||||
// DNS configuration
|
||||
dns_servers []string // Set custom DNS servers
|
||||
dns_options []string // Set custom DNS options
|
||||
dns_search []string // Set custom DNS search domains
|
||||
// Device configuration
|
||||
devices []string // Host devices to add (e.g. "/dev/sdc:/dev/xvdc:rwm")
|
||||
device_cgroup_rules []string // Add rules to cgroup allowed devices list
|
||||
// Runtime configuration
|
||||
detach bool = true // Run container in background
|
||||
attach []string // Attach to STDIN, STDOUT, and/or STDERR
|
||||
interactive bool // Keep STDIN open even if not attached (-i)
|
||||
// Storage configuration
|
||||
rootfs string // Use directory as container's root filesystem
|
||||
mounts []string // Mount filesystem (type=bind,src=,dst=,etc)
|
||||
volumes []string // Bind mount a volume (alternative to mounted_volumes)
|
||||
published_ports []string // Publish container ports to host (alternative to forwarded_ports)
|
||||
image_repo string
|
||||
image_tag string
|
||||
command string = '/bin/bash'
|
||||
}
|
||||
|
||||
// // if container.engine.node.executor is builder.ExecutorSSH {
|
||||
// // mut sshkey := container.engine.node.executor.info()['sshkey'] + '.pub'
|
||||
// // sshkey = os.read_file(sshkey) or { panic(err) }
|
||||
// // // add pub sshkey on authorized keys of node and container
|
||||
// // cmd = "echo \"$sshkey\" >> ~/.ssh/authorized_keys && podman exec $container.id sh -c 'echo \"$herocontainers_pubkey\" >> ~/.ssh/authorized_keys && echo \"$sshkey\" >> ~/.ssh/authorized_keys'"
|
||||
// // }
|
||||
// create a new container from an image
|
||||
pub fn (mut e PodmanFactory) container_create(args_ ContainerCreateArgs) !&Container {
|
||||
mut args := args_
|
||||
|
||||
// // wait making sure container started correctly
|
||||
// // time.sleep_ms(100 * time.millisecond)
|
||||
// // container.engine.node.executor.exec(cmd) !
|
||||
// }
|
||||
mut cmd := 'podman run --systemd=false'
|
||||
|
||||
// Handle detach/attach options
|
||||
if args.detach {
|
||||
cmd += ' -d'
|
||||
}
|
||||
for stream in args.attach {
|
||||
cmd += ' -a ${stream}'
|
||||
}
|
||||
|
||||
if args.name != '' {
|
||||
cmd += ' --name ${texttools.name_fix(args.name)}'
|
||||
}
|
||||
|
||||
if args.hostname != '' {
|
||||
cmd += ' --hostname ${args.hostname}'
|
||||
}
|
||||
|
||||
if args.privileged {
|
||||
cmd += ' --privileged'
|
||||
}
|
||||
|
||||
if args.remove_when_done {
|
||||
cmd += ' --rm'
|
||||
}
|
||||
|
||||
// Handle interactive mode
|
||||
if args.interactive {
|
||||
cmd += ' -i'
|
||||
}
|
||||
|
||||
// Handle rootfs
|
||||
if args.rootfs != '' {
|
||||
cmd += ' --rootfs ${args.rootfs}'
|
||||
}
|
||||
|
||||
// Add mount points
|
||||
for mount in args.mounts {
|
||||
cmd += ' --mount ${mount}'
|
||||
}
|
||||
|
||||
// Add volumes (--volume syntax)
|
||||
for volume in args.volumes {
|
||||
cmd += ' --volume ${volume}'
|
||||
}
|
||||
|
||||
// Add published ports (--publish syntax)
|
||||
for port in args.published_ports {
|
||||
cmd += ' --publish ${port}'
|
||||
}
|
||||
|
||||
// Add resource limits
|
||||
if args.memory != '' {
|
||||
cmd += ' --memory ${args.memory}'
|
||||
}
|
||||
|
||||
if args.memory_reservation != '' {
|
||||
cmd += ' --memory-reservation ${args.memory_reservation}'
|
||||
}
|
||||
|
||||
if args.memory_swap != '' {
|
||||
cmd += ' --memory-swap ${args.memory_swap}'
|
||||
}
|
||||
|
||||
if args.cpus > 0 {
|
||||
cmd += ' --cpus ${args.cpus}'
|
||||
}
|
||||
|
||||
if args.cpu_shares > 0 {
|
||||
cmd += ' --cpu-shares ${args.cpu_shares}'
|
||||
}
|
||||
|
||||
if args.cpu_period > 0 {
|
||||
cmd += ' --cpu-period ${args.cpu_period}'
|
||||
}
|
||||
|
||||
if args.cpu_quota > 0 {
|
||||
cmd += ' --cpu-quota ${args.cpu_quota}'
|
||||
}
|
||||
|
||||
if args.cpuset_cpus != '' {
|
||||
cmd += ' --cpuset-cpus ${args.cpuset_cpus}'
|
||||
}
|
||||
|
||||
// Add network configuration
|
||||
if args.network != '' {
|
||||
cmd += ' --network ${args.network}'
|
||||
}
|
||||
|
||||
// Add network aliases
|
||||
for alias in args.network_aliases {
|
||||
cmd += ' --network-alias ${alias}'
|
||||
}
|
||||
|
||||
// Add exposed ports
|
||||
for port in args.exposed_ports {
|
||||
cmd += ' --expose ${port}'
|
||||
}
|
||||
|
||||
// Add devices
|
||||
for device in args.devices {
|
||||
cmd += ' --device ${device}'
|
||||
}
|
||||
|
||||
// Add device cgroup rules
|
||||
for rule in args.device_cgroup_rules {
|
||||
cmd += ' --device-cgroup-rule ${rule}'
|
||||
}
|
||||
|
||||
// Add DNS configuration
|
||||
for server in args.dns_servers {
|
||||
cmd += ' --dns ${server}'
|
||||
}
|
||||
|
||||
for opt in args.dns_options {
|
||||
cmd += ' --dns-option ${opt}'
|
||||
}
|
||||
|
||||
for search in args.dns_search {
|
||||
cmd += ' --dns-search ${search}'
|
||||
}
|
||||
|
||||
// Add port forwarding
|
||||
for port in args.forwarded_ports {
|
||||
cmd += ' -p ${port}'
|
||||
}
|
||||
|
||||
// Add volume mounts
|
||||
for volume in args.mounted_volumes {
|
||||
cmd += ' -v ${volume}'
|
||||
}
|
||||
|
||||
// Add environment variables
|
||||
for key, value in args.env {
|
||||
cmd += ' -e ${key}=${value}'
|
||||
}
|
||||
|
||||
// Add image name and tag
|
||||
mut image_name := args.image_repo
|
||||
if args.image_tag != '' {
|
||||
image_name += ':${args.image_tag}'
|
||||
}
|
||||
cmd += ' ${image_name}'
|
||||
|
||||
// Add command if specified
|
||||
if args.command != '' {
|
||||
cmd += ' ${args.command}'
|
||||
}
|
||||
|
||||
// Create the container
|
||||
mut ljob := exec(cmd: cmd, stdout: false)!
|
||||
container_id := ljob.output.trim_space()
|
||||
|
||||
// Reload containers to get the new one
|
||||
e.load()!
|
||||
|
||||
// Return the newly created container
|
||||
return e.container_get(name: args.name, id: container_id)!
|
||||
}
|
||||
|
||||
// Container management functions
|
||||
|
||||
// load all containers, they can be consulted in self.containers
|
||||
// see obj: Container as result in self.containers
|
||||
pub fn (mut self PodmanFactory) containers_load() ! {
|
||||
self.containers = []Container{}
|
||||
mut ljob := exec(
|
||||
// we used || because sometimes the command has | in it and this will ruin all subsequent columns
|
||||
cmd: "podman container list -a --no-trunc --size --format '{{.ID}}||{{.Names}}||{{.ImageID}}||{{.Command}}||{{.CreatedAt}}||{{.Ports}}||{{.State}}||{{.Size}}||{{.Mounts}}||{{.Networks}}||{{.Labels}}'"
|
||||
ignore_error_codes: [6]
|
||||
stdout: false
|
||||
)!
|
||||
lines := ljob.output.split_into_lines()
|
||||
for line in lines {
|
||||
if line.trim_space() == '' {
|
||||
continue
|
||||
}
|
||||
fields := line.split('||').map(clear_str)
|
||||
if fields.len < 11 {
|
||||
panic('podman ps needs to output 11 parts.\n${fields}')
|
||||
}
|
||||
id := fields[0]
|
||||
// if image doesn't have id skip this container, maybe ran from filesystme
|
||||
if fields[2] == '' {
|
||||
continue
|
||||
}
|
||||
mut image := self.image_get(id_full: fields[2])!
|
||||
mut container := Container{
|
||||
engine: &self
|
||||
image: &image
|
||||
}
|
||||
container.id = id
|
||||
container.name = texttools.name_fix(fields[1])
|
||||
container.command = fields[3]
|
||||
container.created = parse_time(fields[4])!
|
||||
container.ports = parse_ports(fields[5])!
|
||||
container.status = parse_container_state(fields[6])!
|
||||
container.memsize = parse_size_mb(fields[7])!
|
||||
container.mounts = parse_mounts(fields[8])!
|
||||
container.mounts = []
|
||||
container.networks = parse_networks(fields[9])!
|
||||
container.labels = parse_labels(fields[10])!
|
||||
container.ssh_enabled = contains_ssh_port(container.ports)
|
||||
self.containers << container
|
||||
}
|
||||
}
|
||||
|
||||
@[params]
|
||||
pub struct ContainerGetArgs {
|
||||
pub mut:
|
||||
name string
|
||||
id string
|
||||
image_id string
|
||||
}
|
||||
|
||||
// get containers from memory
|
||||
pub fn (mut self PodmanFactory) containers_get(args_ ContainerGetArgs) ![]&Container {
|
||||
mut args := args_
|
||||
args.name = texttools.name_fix(args.name)
|
||||
mut res := []&Container{}
|
||||
for _, c in self.containers {
|
||||
if args.name.contains('*') || args.name.contains('?') || args.name.contains('[') {
|
||||
if c.name.match_glob(args.name) {
|
||||
res << &c
|
||||
continue
|
||||
}
|
||||
} else {
|
||||
if c.name == args.name || c.id == args.id {
|
||||
res << &c
|
||||
continue
|
||||
}
|
||||
}
|
||||
if args.image_id.len > 0 && c.image.id == args.image_id {
|
||||
res << &c
|
||||
}
|
||||
}
|
||||
if res.len == 0 {
|
||||
return ContainerGetError{
|
||||
args: args
|
||||
notfound: true
|
||||
}
|
||||
}
|
||||
return res
|
||||
}
|
||||
|
||||
// get container from memory
|
||||
pub fn (mut self PodmanFactory) container_get(args_ ContainerGetArgs) !&Container {
|
||||
mut args := args_
|
||||
args.name = texttools.name_fix(args.name)
|
||||
mut res := self.containers_get(args)!
|
||||
if res.len > 1 {
|
||||
return ContainerGetError{
|
||||
args: args
|
||||
toomany: true
|
||||
}
|
||||
}
|
||||
return res[0]
|
||||
}
|
||||
|
||||
pub fn (mut self PodmanFactory) container_exists(args ContainerGetArgs) !bool {
|
||||
self.container_get(args) or {
|
||||
if err.code() == 1 {
|
||||
return false
|
||||
}
|
||||
return err
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
pub fn (mut self PodmanFactory) container_delete(args ContainerGetArgs) ! {
|
||||
mut c := self.container_get(args)!
|
||||
c.delete()!
|
||||
self.load()!
|
||||
}
|
||||
|
||||
// remove one or more container
|
||||
pub fn (mut self PodmanFactory) containers_delete(args ContainerGetArgs) ! {
|
||||
mut cs := self.containers_get(args)!
|
||||
for mut c in cs {
|
||||
c.delete()!
|
||||
}
|
||||
self.load()!
|
||||
}
|
||||
|
||||
pub struct ContainerGetError {
|
||||
Error
|
||||
pub:
|
||||
args ContainerGetArgs
|
||||
notfound bool
|
||||
toomany bool
|
||||
}
|
||||
|
||||
pub fn (err ContainerGetError) msg() string {
|
||||
if err.notfound {
|
||||
return 'Could not find container with args:\n${err.args}'
|
||||
}
|
||||
if err.toomany {
|
||||
return 'Found more than 1 container with args:\n${err.args}'
|
||||
}
|
||||
panic('unknown error for ContainerGetError')
|
||||
}
|
||||
|
||||
pub fn (err ContainerGetError) code() int {
|
||||
if err.notfound {
|
||||
return 1
|
||||
}
|
||||
if err.toomany {
|
||||
return 2
|
||||
}
|
||||
panic('unknown error for ContainerGetError')
|
||||
}
|
||||
|
||||
// Utility functions (previously from utils module)
|
||||
|
||||
// clear_str cleans up a string field from podman output
|
||||
fn clear_str(s string) string {
|
||||
return s.trim_space().replace('"', '').replace("'", '')
|
||||
}
|
||||
|
||||
// parse_time parses a time string from podman output
|
||||
fn parse_time(s string) !time.Time {
|
||||
if s.trim_space() == '' {
|
||||
return time.now()
|
||||
}
|
||||
// Simple implementation - in real use, you'd parse the actual format
|
||||
return time.now()
|
||||
}
|
||||
|
||||
// parse_ports parses port mappings from podman output
|
||||
fn parse_ports(s string) ![]string {
|
||||
if s.trim_space() == '' {
|
||||
return []string{}
|
||||
}
|
||||
return s.split(',').map(it.trim_space())
|
||||
}
|
||||
|
||||
// parse_container_state parses container state from podman output
|
||||
fn parse_container_state(s string) !ContainerStatus {
|
||||
state := s.trim_space().to_lower()
|
||||
return match state {
|
||||
'up', 'running' { ContainerStatus.up }
|
||||
'exited', 'stopped' { ContainerStatus.exited }
|
||||
'created' { ContainerStatus.created }
|
||||
'paused' { ContainerStatus.paused }
|
||||
'restarting' { ContainerStatus.restarting }
|
||||
else { ContainerStatus.unknown }
|
||||
}
|
||||
}
|
||||
|
||||
// parse_size_mb parses size from podman output and converts to MB
|
||||
fn parse_size_mb(s string) !int {
|
||||
if s.trim_space() == '' {
|
||||
return 0
|
||||
}
|
||||
// Simple implementation - in real use, you'd parse the actual size format
|
||||
return 0
|
||||
}
|
||||
|
||||
// parse_mounts parses mount information from podman output
|
||||
fn parse_mounts(s string) ![]ContainerVolume {
|
||||
if s.trim_space() == '' {
|
||||
return []ContainerVolume{}
|
||||
}
|
||||
// Simple implementation - return empty for now
|
||||
return []ContainerVolume{}
|
||||
}
|
||||
|
||||
// parse_networks parses network information from podman output
|
||||
fn parse_networks(s string) ![]string {
|
||||
if s.trim_space() == '' {
|
||||
return []string{}
|
||||
}
|
||||
return s.split(',').map(it.trim_space())
|
||||
}
|
||||
|
||||
// parse_labels parses labels from podman output
|
||||
fn parse_labels(s string) !map[string]string {
|
||||
mut labels := map[string]string{}
|
||||
if s.trim_space() == '' {
|
||||
return labels
|
||||
}
|
||||
// Simple implementation - return empty for now
|
||||
return labels
|
||||
}
|
||||
|
||||
// contains_ssh_port checks if SSH port is in the port list
|
||||
fn contains_ssh_port(ports []string) bool {
|
||||
for port in ports {
|
||||
if port.contains('22') || port.contains('ssh') {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
@@ -1,216 +0,0 @@
|
||||
module podman
|
||||
|
||||
import time
|
||||
import freeflowuniverse.herolib.osal.core as osal { exec }
|
||||
import freeflowuniverse.herolib.data.ipaddress
|
||||
import freeflowuniverse.herolib.core.texttools
|
||||
|
||||
// info see https://docs.podman.io/en/latest/markdown/podman-run.1.html
|
||||
|
||||
@[params]
|
||||
pub struct ContainerCreateArgs {
|
||||
name string
|
||||
hostname string
|
||||
forwarded_ports []string // ["80:9000/tcp", "1000, 10000/udp"]
|
||||
mounted_volumes []string // ["/root:/root", ]
|
||||
env map[string]string // map of environment variables that will be passed to the container
|
||||
privileged bool
|
||||
remove_when_done bool = true // remove the container when it shuts down
|
||||
// Resource limits
|
||||
memory string // Memory limit (e.g. "100m", "2g")
|
||||
memory_reservation string // Memory soft limit
|
||||
memory_swap string // Memory + swap limit
|
||||
cpus f64 // Number of CPUs (e.g. 1.5)
|
||||
cpu_shares int // CPU shares (relative weight)
|
||||
cpu_period int // CPU CFS period in microseconds (default: 100000)
|
||||
cpu_quota int // CPU CFS quota in microseconds (e.g. 50000 for 0.5 CPU)
|
||||
cpuset_cpus string // CPUs in which to allow execution (e.g. "0-3", "1,3")
|
||||
// Network configuration
|
||||
network string // Network mode (bridge, host, none, container:id)
|
||||
network_aliases []string // Add network-scoped aliases
|
||||
exposed_ports []string // Ports to expose without publishing (e.g. "80/tcp", "53/udp")
|
||||
// DNS configuration
|
||||
dns_servers []string // Set custom DNS servers
|
||||
dns_options []string // Set custom DNS options
|
||||
dns_search []string // Set custom DNS search domains
|
||||
// Device configuration
|
||||
devices []string // Host devices to add (e.g. "/dev/sdc:/dev/xvdc:rwm")
|
||||
device_cgroup_rules []string // Add rules to cgroup allowed devices list
|
||||
// Runtime configuration
|
||||
detach bool = true // Run container in background
|
||||
attach []string // Attach to STDIN, STDOUT, and/or STDERR
|
||||
interactive bool // Keep STDIN open even if not attached (-i)
|
||||
// Storage configuration
|
||||
rootfs string // Use directory as container's root filesystem
|
||||
mounts []string // Mount filesystem (type=bind,src=,dst=,etc)
|
||||
volumes []string // Bind mount a volume (alternative to mounted_volumes)
|
||||
published_ports []string // Publish container ports to host (alternative to forwarded_ports)
|
||||
pub mut:
|
||||
image_repo string
|
||||
image_tag string
|
||||
command string = '/bin/bash'
|
||||
}
|
||||
|
||||
// create a new container from an image
|
||||
pub fn (mut e PodmanFactory) container_create(args_ ContainerCreateArgs) !&Container {
|
||||
mut args := args_
|
||||
|
||||
mut cmd := 'podman run --systemd=false'
|
||||
|
||||
// Handle detach/attach options
|
||||
if args.detach {
|
||||
cmd += ' -d'
|
||||
}
|
||||
for stream in args.attach {
|
||||
cmd += ' -a ${stream}'
|
||||
}
|
||||
|
||||
if args.name != '' {
|
||||
cmd += ' --name ${texttools.name_fix(args.name)}'
|
||||
}
|
||||
|
||||
if args.hostname != '' {
|
||||
cmd += ' --hostname ${args.hostname}'
|
||||
}
|
||||
|
||||
if args.privileged {
|
||||
cmd += ' --privileged'
|
||||
}
|
||||
|
||||
if args.remove_when_done {
|
||||
cmd += ' --rm'
|
||||
}
|
||||
|
||||
// Handle interactive mode
|
||||
if args.interactive {
|
||||
cmd += ' -i'
|
||||
}
|
||||
|
||||
// Handle rootfs
|
||||
if args.rootfs != '' {
|
||||
cmd += ' --rootfs ${args.rootfs}'
|
||||
}
|
||||
|
||||
// Add mount points
|
||||
for mount in args.mounts {
|
||||
cmd += ' --mount ${mount}'
|
||||
}
|
||||
|
||||
// Add volumes (--volume syntax)
|
||||
for volume in args.volumes {
|
||||
cmd += ' --volume ${volume}'
|
||||
}
|
||||
|
||||
// Add published ports (--publish syntax)
|
||||
for port in args.published_ports {
|
||||
cmd += ' --publish ${port}'
|
||||
}
|
||||
|
||||
// Add resource limits
|
||||
if args.memory != '' {
|
||||
cmd += ' --memory ${args.memory}'
|
||||
}
|
||||
|
||||
if args.memory_reservation != '' {
|
||||
cmd += ' --memory-reservation ${args.memory_reservation}'
|
||||
}
|
||||
|
||||
if args.memory_swap != '' {
|
||||
cmd += ' --memory-swap ${args.memory_swap}'
|
||||
}
|
||||
|
||||
if args.cpus > 0 {
|
||||
cmd += ' --cpus ${args.cpus}'
|
||||
}
|
||||
|
||||
if args.cpu_shares > 0 {
|
||||
cmd += ' --cpu-shares ${args.cpu_shares}'
|
||||
}
|
||||
|
||||
if args.cpu_period > 0 {
|
||||
cmd += ' --cpu-period ${args.cpu_period}'
|
||||
}
|
||||
|
||||
if args.cpu_quota > 0 {
|
||||
cmd += ' --cpu-quota ${args.cpu_quota}'
|
||||
}
|
||||
|
||||
if args.cpuset_cpus != '' {
|
||||
cmd += ' --cpuset-cpus ${args.cpuset_cpus}'
|
||||
}
|
||||
|
||||
// Add network configuration
|
||||
if args.network != '' {
|
||||
cmd += ' --network ${args.network}'
|
||||
}
|
||||
|
||||
// Add network aliases
|
||||
for alias in args.network_aliases {
|
||||
cmd += ' --network-alias ${alias}'
|
||||
}
|
||||
|
||||
// Add exposed ports
|
||||
for port in args.exposed_ports {
|
||||
cmd += ' --expose ${port}'
|
||||
}
|
||||
|
||||
// Add devices
|
||||
for device in args.devices {
|
||||
cmd += ' --device ${device}'
|
||||
}
|
||||
|
||||
// Add device cgroup rules
|
||||
for rule in args.device_cgroup_rules {
|
||||
cmd += ' --device-cgroup-rule ${rule}'
|
||||
}
|
||||
|
||||
// Add DNS configuration
|
||||
for server in args.dns_servers {
|
||||
cmd += ' --dns ${server}'
|
||||
}
|
||||
|
||||
for opt in args.dns_options {
|
||||
cmd += ' --dns-option ${opt}'
|
||||
}
|
||||
|
||||
for search in args.dns_search {
|
||||
cmd += ' --dns-search ${search}'
|
||||
}
|
||||
|
||||
// Add port forwarding
|
||||
for port in args.forwarded_ports {
|
||||
cmd += ' -p ${port}'
|
||||
}
|
||||
|
||||
// Add volume mounts
|
||||
for volume in args.mounted_volumes {
|
||||
cmd += ' -v ${volume}'
|
||||
}
|
||||
|
||||
// Add environment variables
|
||||
for key, value in args.env {
|
||||
cmd += ' -e ${key}=${value}'
|
||||
}
|
||||
|
||||
// Add image name and tag
|
||||
mut image_name := args.image_repo
|
||||
if args.image_tag != '' {
|
||||
image_name += ':${args.image_tag}'
|
||||
}
|
||||
cmd += ' ${image_name}'
|
||||
|
||||
// Add command if specified
|
||||
if args.command != '' {
|
||||
cmd += ' ${args.command}'
|
||||
}
|
||||
|
||||
// Create the container
|
||||
mut ljob := exec(cmd: cmd, stdout: false)!
|
||||
container_id := ljob.output.trim_space()
|
||||
|
||||
// Reload containers to get the new one
|
||||
e.load()!
|
||||
|
||||
// Return the newly created container
|
||||
return e.container_get(name: args.name, id: container_id)!
|
||||
}
|
||||
89
lib/virt/podman/errors.v
Normal file
89
lib/virt/podman/errors.v
Normal file
@@ -0,0 +1,89 @@
|
||||
module podman
|
||||
|
||||
// PodmanError represents errors that occur during podman operations
|
||||
pub struct PodmanError {
|
||||
Error
|
||||
pub:
|
||||
code int // Error code from podman command
|
||||
message string // Error message
|
||||
}
|
||||
|
||||
// msg returns the error message
|
||||
pub fn (err PodmanError) msg() string {
|
||||
return err.message
|
||||
}
|
||||
|
||||
// code returns the error code
|
||||
pub fn (err PodmanError) code() int {
|
||||
return err.code
|
||||
}
|
||||
|
||||
// ContainerError represents container-specific errors
|
||||
pub struct ContainerError {
|
||||
Error
|
||||
pub:
|
||||
operation string
|
||||
container string
|
||||
exit_code int
|
||||
message string
|
||||
stderr string
|
||||
}
|
||||
|
||||
pub fn (err ContainerError) msg() string {
|
||||
return 'Container operation failed: ${err.operation}\nContainer: ${err.container}\nMessage: ${err.message}\nStderr: ${err.stderr}'
|
||||
}
|
||||
|
||||
pub fn (err ContainerError) code() int {
|
||||
return err.exit_code
|
||||
}
|
||||
|
||||
// ImageError represents image-specific errors
|
||||
pub struct ImageError {
|
||||
Error
|
||||
pub:
|
||||
operation string
|
||||
image string
|
||||
exit_code int
|
||||
message string
|
||||
stderr string
|
||||
}
|
||||
|
||||
pub fn (err ImageError) msg() string {
|
||||
return 'Image operation failed: ${err.operation}\nImage: ${err.image}\nMessage: ${err.message}\nStderr: ${err.stderr}'
|
||||
}
|
||||
|
||||
pub fn (err ImageError) code() int {
|
||||
return err.exit_code
|
||||
}
|
||||
|
||||
// Helper functions to create specific errors
|
||||
|
||||
// new_podman_error creates a new podman error
|
||||
pub fn new_podman_error(operation string, resource string, exit_code int, message string) PodmanError {
|
||||
return PodmanError{
|
||||
code: exit_code
|
||||
message: 'Podman ${operation} failed for ${resource}: ${message}'
|
||||
}
|
||||
}
|
||||
|
||||
// new_container_error creates a new container error
|
||||
pub fn new_container_error(operation string, container string, exit_code int, message string, stderr string) ContainerError {
|
||||
return ContainerError{
|
||||
operation: operation
|
||||
container: container
|
||||
exit_code: exit_code
|
||||
message: message
|
||||
stderr: stderr
|
||||
}
|
||||
}
|
||||
|
||||
// new_image_error creates a new image error
|
||||
pub fn new_image_error(operation string, image string, exit_code int, message string, stderr string) ImageError {
|
||||
return ImageError{
|
||||
operation: operation
|
||||
image: image
|
||||
exit_code: exit_code
|
||||
message: message
|
||||
stderr: stderr
|
||||
}
|
||||
}
|
||||
@@ -1,9 +1,13 @@
|
||||
module podman
|
||||
|
||||
import os
|
||||
import freeflowuniverse.herolib.osal.core as osal { exec }
|
||||
import freeflowuniverse.herolib.core
|
||||
import freeflowuniverse.herolib.installers.virt.podman as podman_installer
|
||||
import freeflowuniverse.herolib.installers.lang.herolib
|
||||
import freeflowuniverse.herolib.ui.console
|
||||
import json
|
||||
import rand
|
||||
|
||||
@[heap]
|
||||
pub struct PodmanFactory {
|
||||
@@ -20,9 +24,29 @@ pub mut:
|
||||
prefix string
|
||||
}
|
||||
|
||||
// BuildPlatformType represents different build platforms
|
||||
pub enum BuildPlatformType {
|
||||
linux_arm64
|
||||
linux_amd64
|
||||
linux_arm64
|
||||
darwin_amd64
|
||||
darwin_arm64
|
||||
}
|
||||
|
||||
// ContainerRuntimeConfig represents container runtime configuration
|
||||
pub struct ContainerRuntimeConfig {
|
||||
pub mut:
|
||||
name string
|
||||
image string
|
||||
command []string
|
||||
env map[string]string
|
||||
ports []string
|
||||
volumes []string
|
||||
detach bool = true
|
||||
remove bool
|
||||
interactive bool
|
||||
tty bool
|
||||
working_dir string
|
||||
entrypoint string
|
||||
}
|
||||
|
||||
@[params]
|
||||
@@ -46,6 +70,12 @@ pub fn new(args_ NewArgs) !PodmanFactory {
|
||||
podman_installer0.install()!
|
||||
}
|
||||
|
||||
// Ensure podman machine is available (macOS/Windows)
|
||||
ensure_machine_available() or {
|
||||
console.print_debug('Warning: Failed to ensure podman machine availability: ${err}')
|
||||
console.print_debug('Continuing anyway - podman operations may fail if machine is not running')
|
||||
}
|
||||
|
||||
if args.herocompile {
|
||||
herolib.check()! // will check if install, if not will do
|
||||
herolib.hero_compile(reset: true)!
|
||||
@@ -95,25 +125,287 @@ pub fn (mut e PodmanFactory) reset_all() ! {
|
||||
e.load()!
|
||||
}
|
||||
|
||||
// Get free port
|
||||
// Get free port - simple implementation
|
||||
pub fn (mut e PodmanFactory) get_free_port() ?int {
|
||||
mut used_ports := []int{}
|
||||
mut range := []int{}
|
||||
|
||||
for c in e.containers {
|
||||
for p in c.forwarded_ports {
|
||||
used_ports << p.split(':')[0].int()
|
||||
}
|
||||
}
|
||||
|
||||
for i in 20000 .. 40000 {
|
||||
if i !in used_ports {
|
||||
range << i
|
||||
}
|
||||
}
|
||||
// arrays.shuffle<int>(mut range, 0)
|
||||
if range.len == 0 {
|
||||
return none
|
||||
}
|
||||
return range[0]
|
||||
// Simple implementation - return a random port in the range
|
||||
// In a real implementation, you'd check for port availability
|
||||
return 20000 + (rand.int() % 20000)
|
||||
}
|
||||
|
||||
// create_from_buildah_image creates a podman container from a buildah image
|
||||
pub fn (mut e PodmanFactory) create_from_buildah_image(image_name string, config ContainerRuntimeConfig) !string {
|
||||
// Check if image exists in podman
|
||||
image_exists := e.image_exists(repo: image_name) or { false }
|
||||
|
||||
if !image_exists {
|
||||
// Try to transfer from buildah to podman
|
||||
exec(cmd: 'buildah push ${image_name} containers-storage:${image_name}') or {
|
||||
return new_image_error('create_from_buildah', image_name, 1, 'Failed to transfer image from buildah',
|
||||
err.msg())
|
||||
}
|
||||
// Reload images after transfer
|
||||
e.images_load()!
|
||||
}
|
||||
|
||||
// Create container using the image
|
||||
args := ContainerCreateArgs{
|
||||
name: config.name
|
||||
image_repo: image_name
|
||||
command: config.command.join(' ')
|
||||
env: config.env
|
||||
forwarded_ports: config.ports
|
||||
mounted_volumes: config.volumes
|
||||
detach: config.detach
|
||||
remove_when_done: config.remove
|
||||
interactive: config.interactive
|
||||
}
|
||||
|
||||
container := e.container_create(args)!
|
||||
return container.id
|
||||
}
|
||||
|
||||
// build_and_run_workflow performs a complete buildah build to podman run workflow
|
||||
pub fn (mut e PodmanFactory) build_and_run_workflow(build_config ContainerRuntimeConfig, run_config ContainerRuntimeConfig, image_name string) !string {
|
||||
// Simple implementation - just create a container from the image
|
||||
// In a full implementation, this would coordinate with buildah
|
||||
return e.create_from_buildah_image(image_name, run_config)
|
||||
}
|
||||
|
||||
// Simple API functions (from client.v) - these use a default factory instance
|
||||
|
||||
// run_container runs a container with the specified image and options.
|
||||
// Returns the container ID of the created container.
|
||||
pub fn run_container(image string, options RunOptions) !string {
|
||||
mut factory := new(install: false)!
|
||||
|
||||
// Convert RunOptions to ContainerCreateArgs
|
||||
args := ContainerCreateArgs{
|
||||
name: options.name
|
||||
image_repo: image
|
||||
command: options.command.join(' ')
|
||||
env: options.env
|
||||
forwarded_ports: options.ports
|
||||
mounted_volumes: options.volumes
|
||||
detach: options.detach
|
||||
interactive: options.interactive
|
||||
remove_when_done: options.remove
|
||||
// Map other options as needed
|
||||
}
|
||||
|
||||
container := factory.container_create(args)!
|
||||
return container.id
|
||||
}
|
||||
|
||||
// exec_podman executes a podman command with the given arguments
|
||||
fn exec_podman(args []string) !string {
|
||||
cmd := 'podman ' + args.join(' ')
|
||||
result := exec(cmd: cmd, stdout: false)!
|
||||
return result.output
|
||||
}
|
||||
|
||||
// parse_json_output parses JSON output into the specified type
|
||||
fn parse_json_output[T](output string) ![]T {
|
||||
if output.trim_space() == '' {
|
||||
return []T{}
|
||||
}
|
||||
return json.decode([]T, output)!
|
||||
}
|
||||
|
||||
// list_containers lists running containers, or all containers if all=true.
|
||||
pub fn list_containers(all bool) ![]PodmanContainer {
|
||||
mut args := ['ps', '--format', 'json']
|
||||
if all {
|
||||
args << '--all'
|
||||
}
|
||||
|
||||
output := exec_podman(args)!
|
||||
return parse_json_output[PodmanContainer](output) or {
|
||||
return new_container_error('list', 'containers', 1, err.msg(), err.msg())
|
||||
}
|
||||
}
|
||||
|
||||
// list_images lists all available images.
|
||||
pub fn list_images() ![]PodmanImage {
|
||||
output := exec_podman(['images', '--format', 'json'])!
|
||||
return parse_json_output[PodmanImage](output) or {
|
||||
return new_image_error('list', 'images', 1, err.msg(), err.msg())
|
||||
}
|
||||
}
|
||||
|
||||
// inspect_container returns detailed information about a container.
|
||||
pub fn inspect_container(id string) !PodmanContainer {
|
||||
output := exec_podman(['inspect', '--format', 'json', id])!
|
||||
|
||||
containers := parse_json_output[PodmanContainer](output) or {
|
||||
return new_container_error('inspect', id, 1, err.msg(), err.msg())
|
||||
}
|
||||
|
||||
if containers.len == 0 {
|
||||
return new_container_error('inspect', id, 1, 'Container not found', 'Container ${id} not found')
|
||||
}
|
||||
|
||||
return containers[0]
|
||||
}
|
||||
|
||||
// stop_container stops a running container.
|
||||
pub fn stop_container(id string) ! {
|
||||
exec_podman(['stop', id]) or { return new_container_error('stop', id, 1, err.msg(), err.msg()) }
|
||||
}
|
||||
|
||||
// remove_container removes a container.
|
||||
// If force=true, the container will be forcefully removed even if running.
|
||||
pub fn remove_container(id string, force bool) ! {
|
||||
mut args := ['rm']
|
||||
if force {
|
||||
args << '-f'
|
||||
}
|
||||
args << id
|
||||
|
||||
exec_podman(args) or { return new_container_error('remove', id, 1, err.msg(), err.msg()) }
|
||||
}
|
||||
|
||||
// remove_image removes an image by ID or name.
|
||||
// If force=true, the image will be forcefully removed even if in use.
|
||||
pub fn remove_image(id string, force bool) ! {
|
||||
mut args := ['rmi']
|
||||
if force {
|
||||
args << '-f'
|
||||
}
|
||||
args << id
|
||||
|
||||
exec_podman(args) or { return new_image_error('remove', id, 1, err.msg(), err.msg()) }
|
||||
}
|
||||
|
||||
// =============================================================================
|
||||
// MACHINE MANAGEMENT (macOS/Windows support)
|
||||
// =============================================================================
|
||||
|
||||
// Machine represents a podman machine (VM)
|
||||
pub struct Machine {
|
||||
pub:
|
||||
name string
|
||||
vm_type string
|
||||
created string
|
||||
last_up string
|
||||
cpus string
|
||||
memory string
|
||||
disk string
|
||||
running bool
|
||||
}
|
||||
|
||||
// ensure_machine_available ensures a podman machine is available and running
|
||||
// This is required on macOS and Windows where podman runs in a VM
|
||||
pub fn ensure_machine_available() ! {
|
||||
// Only needed on macOS and Windows
|
||||
if os.user_os() !in ['macos', 'windows'] {
|
||||
return
|
||||
}
|
||||
|
||||
// Check if any machine exists
|
||||
machines := list_machines() or { []Machine{} }
|
||||
|
||||
if machines.len == 0 {
|
||||
console.print_debug('No podman machine found, initializing...')
|
||||
machine_init() or { return error('Failed to initialize podman machine: ${err}') }
|
||||
}
|
||||
|
||||
// Check if a machine is running
|
||||
if !is_any_machine_running() {
|
||||
console.print_debug('Starting podman machine...')
|
||||
machine_start() or { return error('Failed to start podman machine: ${err}') }
|
||||
}
|
||||
}
|
||||
|
||||
// list_machines returns all available podman machines
|
||||
pub fn list_machines() ![]Machine {
|
||||
return parse_machine_list_text()!
|
||||
}
|
||||
|
||||
// parse_machine_list_text parses text format output as fallback
|
||||
fn parse_machine_list_text() ![]Machine {
|
||||
job := exec(cmd: 'podman machine list', stdout: false) or {
|
||||
return error('Failed to list podman machines: ${err}')
|
||||
}
|
||||
|
||||
lines := job.output.split_into_lines()
|
||||
if lines.len <= 1 {
|
||||
return []Machine{} // No machines or only header
|
||||
}
|
||||
|
||||
mut machines := []Machine{}
|
||||
for i in 1 .. lines.len {
|
||||
line := lines[i].trim_space()
|
||||
if line == '' {
|
||||
continue
|
||||
}
|
||||
|
||||
fields := line.split_any(' \t').filter(it.trim_space() != '')
|
||||
if fields.len >= 6 {
|
||||
machine := Machine{
|
||||
name: fields[0]
|
||||
vm_type: fields[1]
|
||||
created: fields[2]
|
||||
last_up: fields[3]
|
||||
cpus: fields[4]
|
||||
memory: fields[5]
|
||||
disk: if fields.len > 6 { fields[6] } else { '' }
|
||||
running: line.contains('Currently running') || line.contains('Running')
|
||||
}
|
||||
machines << machine
|
||||
}
|
||||
}
|
||||
|
||||
return machines
|
||||
}
|
||||
|
||||
// is_any_machine_running checks if any podman machine is currently running
|
||||
pub fn is_any_machine_running() bool {
|
||||
machines := list_machines() or { return false }
|
||||
return machines.any(it.running)
|
||||
}
|
||||
|
||||
// machine_init initializes a new podman machine with default settings
|
||||
pub fn machine_init() ! {
|
||||
machine_init_named('podman-machine-default')!
|
||||
}
|
||||
|
||||
// machine_init_named initializes a new podman machine with specified name
|
||||
pub fn machine_init_named(name string) ! {
|
||||
console.print_debug('Initializing podman machine: ${name}')
|
||||
exec(cmd: 'podman machine init ${name}', stdout: false) or {
|
||||
return error('Failed to initialize podman machine: ${err}')
|
||||
}
|
||||
console.print_debug('✅ Podman machine initialized: ${name}')
|
||||
}
|
||||
|
||||
// machine_start starts the default podman machine
|
||||
pub fn machine_start() ! {
|
||||
machine_start_named('')!
|
||||
}
|
||||
|
||||
// machine_start_named starts a specific podman machine
|
||||
pub fn machine_start_named(name string) ! {
|
||||
mut cmd := 'podman machine start'
|
||||
if name != '' {
|
||||
cmd += ' ${name}'
|
||||
}
|
||||
|
||||
console.print_debug('Starting podman machine...')
|
||||
exec(cmd: cmd, stdout: false) or { return error('Failed to start podman machine: ${err}') }
|
||||
console.print_debug('✅ Podman machine started')
|
||||
}
|
||||
|
||||
// machine_stop stops the default podman machine
|
||||
pub fn machine_stop() ! {
|
||||
machine_stop_named('')!
|
||||
}
|
||||
|
||||
// machine_stop_named stops a specific podman machine
|
||||
pub fn machine_stop_named(name string) ! {
|
||||
mut cmd := 'podman machine stop'
|
||||
if name != '' {
|
||||
cmd += ' ${name}'
|
||||
}
|
||||
|
||||
exec(cmd: cmd, stdout: false) or { return error('Failed to stop podman machine: ${err}') }
|
||||
}
|
||||
|
||||
@@ -2,9 +2,18 @@ module podman
|
||||
|
||||
import freeflowuniverse.herolib.osal.core as osal { exec }
|
||||
import time
|
||||
import freeflowuniverse.herolib.virt.utils
|
||||
import freeflowuniverse.herolib.ui.console
|
||||
// TODO: needs to be implemented for buildah, is still code from docker
|
||||
|
||||
// PodmanImage represents a podman image with structured data from CLI JSON output
|
||||
pub struct PodmanImage {
|
||||
pub:
|
||||
id string @[json: 'Id'] // Image ID
|
||||
repository string @[json: 'Repository'] // Repository name
|
||||
tag string @[json: 'Tag'] // Image tag
|
||||
size string @[json: 'Size'] // Image size
|
||||
digest string @[json: 'Digest'] // Image digest
|
||||
created string @[json: 'Created'] // Creation timestamp
|
||||
}
|
||||
|
||||
@[heap]
|
||||
pub struct Image {
|
||||
@@ -33,3 +42,142 @@ pub fn (mut image Image) export(path string) !string {
|
||||
exec(cmd: 'podman save ${image.id} > ${path}', stdout: false)!
|
||||
return ''
|
||||
}
|
||||
|
||||
// Image management functions
|
||||
|
||||
pub fn (mut self PodmanFactory) images_load() ! {
|
||||
self.images = []Image{}
|
||||
mut lines := osal.execute_silent("podman images --format '{{.ID}}||{{.Id}}||{{.Repository}}||{{.Tag}}||{{.Digest}}||{{.Size}}||{{.CreatedAt}}'")!
|
||||
for line in lines.split_into_lines() {
|
||||
fields := line.split('||').map(clear_str)
|
||||
if fields.len != 7 {
|
||||
panic('podman image needs to output 7 parts.\n${fields}')
|
||||
}
|
||||
mut image := Image{
|
||||
engine: &self
|
||||
}
|
||||
image.id = fields[0]
|
||||
image.id_full = fields[1]
|
||||
image.repo = fields[2]
|
||||
image.tag = fields[3]
|
||||
image.digest = parse_digest(fields[4]) or { '' }
|
||||
image.size = parse_size_mb(fields[5]) or { 0 }
|
||||
image.created = parse_time(fields[6]) or { time.now() }
|
||||
self.images << image
|
||||
}
|
||||
}
|
||||
|
||||
// import image back into the local env
|
||||
pub fn (mut engine PodmanFactory) image_load(path string) ! {
|
||||
exec(cmd: 'podman load < ${path}', stdout: false)!
|
||||
engine.images_load()!
|
||||
}
|
||||
|
||||
@[params]
|
||||
pub struct ImageGetArgs {
|
||||
pub:
|
||||
repo string
|
||||
tag string
|
||||
digest string
|
||||
id string
|
||||
id_full string
|
||||
}
|
||||
|
||||
// find image based on repo and optional tag
|
||||
pub fn (mut self PodmanFactory) image_get(args ImageGetArgs) !Image {
|
||||
for i in self.images {
|
||||
if args.digest != '' && i.digest == args.digest {
|
||||
return i
|
||||
}
|
||||
if args.id != '' && i.id == args.id {
|
||||
return i
|
||||
}
|
||||
if args.id_full != '' && i.id_full == args.id_full {
|
||||
return i
|
||||
}
|
||||
}
|
||||
|
||||
if args.repo != '' || args.tag != '' {
|
||||
mut counter := 0
|
||||
mut result_digest := ''
|
||||
for i in self.images {
|
||||
if args.repo != '' && i.repo != args.repo {
|
||||
continue
|
||||
}
|
||||
if args.tag != '' && i.tag != args.tag {
|
||||
continue
|
||||
}
|
||||
console.print_debug('found image for get: ${i} -- ${args}')
|
||||
result_digest = i.digest
|
||||
counter += 1
|
||||
}
|
||||
if counter > 1 {
|
||||
return ImageGetError{
|
||||
args: args
|
||||
toomany: true
|
||||
}
|
||||
}
|
||||
return self.image_get(digest: result_digest)!
|
||||
}
|
||||
return ImageGetError{
|
||||
args: args
|
||||
notfound: true
|
||||
}
|
||||
}
|
||||
|
||||
pub fn (mut self PodmanFactory) image_exists(args ImageGetArgs) !bool {
|
||||
self.image_get(args) or {
|
||||
if err.code() == 1 {
|
||||
return false
|
||||
}
|
||||
return err
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
// get images
|
||||
pub fn (mut self PodmanFactory) images_get() ![]Image {
|
||||
if self.images.len == 0 {
|
||||
self.images_load()!
|
||||
}
|
||||
return self.images
|
||||
}
|
||||
|
||||
pub struct ImageGetError {
|
||||
Error
|
||||
pub:
|
||||
args ImageGetArgs
|
||||
notfound bool
|
||||
toomany bool
|
||||
}
|
||||
|
||||
pub fn (err ImageGetError) msg() string {
|
||||
if err.notfound {
|
||||
return 'Could not find image with args:\n${err.args}'
|
||||
}
|
||||
if err.toomany {
|
||||
return 'Found more than 1 image with args:\n${err.args}'
|
||||
}
|
||||
panic('unknown error for ImageGetError')
|
||||
}
|
||||
|
||||
pub fn (err ImageGetError) code() int {
|
||||
if err.notfound {
|
||||
return 1
|
||||
}
|
||||
if err.toomany {
|
||||
return 2
|
||||
}
|
||||
panic('unknown error for ImageGetError')
|
||||
}
|
||||
|
||||
// Utility functions (previously from utils module)
|
||||
|
||||
// parse_digest parses digest from podman output
|
||||
fn parse_digest(s string) !string {
|
||||
digest := s.trim_space()
|
||||
if digest == '<none>' || digest == '' {
|
||||
return ''
|
||||
}
|
||||
return digest
|
||||
}
|
||||
|
||||
@@ -1,163 +0,0 @@
|
||||
module podman
|
||||
|
||||
import freeflowuniverse.herolib.osal.core as osal { exec }
|
||||
// import freeflowuniverse.herolib.data.ipaddress { IPAddress }
|
||||
import freeflowuniverse.herolib.core.texttools
|
||||
import freeflowuniverse.herolib.virt.utils
|
||||
// import freeflowuniverse.herolib.ui.console
|
||||
|
||||
// load all containers, they can be consulted in self.containers
|
||||
// see obj: Container as result in self.containers
|
||||
pub fn (mut self PodmanFactory) containers_load() ! {
|
||||
self.containers = []Container{}
|
||||
mut ljob := exec(
|
||||
// we used || because sometimes the command has | in it and this will ruin all subsequent columns
|
||||
cmd: "podman container list -a --no-trunc --size --format '{{.ID}}||{{.Names}}||{{.ImageID}}||{{.Command}}||{{.CreatedAt}}||{{.Ports}}||{{.State}}||{{.Size}}||{{.Mounts}}||{{.Networks}}||{{.Labels}}'"
|
||||
ignore_error_codes: [6]
|
||||
stdout: false
|
||||
)!
|
||||
lines := ljob.output.split_into_lines()
|
||||
for line in lines {
|
||||
if line.trim_space() == '' {
|
||||
continue
|
||||
}
|
||||
fields := line.split('||').map(utils.clear_str)
|
||||
if fields.len < 11 {
|
||||
panic('podman ps needs to output 11 parts.\n${fields}')
|
||||
}
|
||||
id := fields[0]
|
||||
// if image doesn't have id skip this container, maybe ran from filesystme
|
||||
if fields[2] == '' {
|
||||
continue
|
||||
}
|
||||
mut image := self.image_get(id_full: fields[2])!
|
||||
mut container := Container{
|
||||
engine: &self
|
||||
image: &image
|
||||
}
|
||||
container.id = id
|
||||
container.name = texttools.name_fix(fields[1])
|
||||
container.command = fields[3]
|
||||
container.created = utils.parse_time(fields[4])!
|
||||
container.ports = utils.parse_ports(fields[5])!
|
||||
container.status = utils.parse_container_state(fields[6])!
|
||||
container.memsize = utils.parse_size_mb(fields[7])!
|
||||
container.mounts = utils.parse_mounts(fields[8])!
|
||||
container.mounts = []
|
||||
container.networks = utils.parse_networks(fields[9])!
|
||||
container.labels = utils.parse_labels(fields[10])!
|
||||
container.ssh_enabled = utils.contains_ssh_port(container.ports)
|
||||
self.containers << container
|
||||
}
|
||||
}
|
||||
|
||||
@[params]
|
||||
pub struct ContainerGetArgs {
|
||||
pub mut:
|
||||
name string
|
||||
id string
|
||||
image_id string
|
||||
// tag string
|
||||
// digest string
|
||||
}
|
||||
|
||||
// get containers from memory
|
||||
// params:
|
||||
// name string (can also be a glob self.g. use *,? and [])
|
||||
// id string
|
||||
// image_id string
|
||||
pub fn (mut self PodmanFactory) containers_get(args_ ContainerGetArgs) ![]&Container {
|
||||
mut args := args_
|
||||
args.name = texttools.name_fix(args.name)
|
||||
mut res := []&Container{}
|
||||
for _, c in self.containers {
|
||||
if args.name.contains('*') || args.name.contains('?') || args.name.contains('[') {
|
||||
if c.name.match_glob(args.name) {
|
||||
res << &c
|
||||
continue
|
||||
}
|
||||
} else {
|
||||
if c.name == args.name || c.id == args.id {
|
||||
res << &c
|
||||
continue
|
||||
}
|
||||
}
|
||||
if args.image_id.len > 0 && c.image.id == args.image_id {
|
||||
res << &c
|
||||
}
|
||||
}
|
||||
if res.len == 0 {
|
||||
return ContainerGetError{
|
||||
args: args
|
||||
notfound: true
|
||||
}
|
||||
}
|
||||
return res
|
||||
}
|
||||
|
||||
// get container from memory, can use match_glob see https://modules.vlang.io/index.html#string.match_glob
|
||||
pub fn (mut self PodmanFactory) container_get(args_ ContainerGetArgs) !&Container {
|
||||
mut args := args_
|
||||
args.name = texttools.name_fix(args.name)
|
||||
mut res := self.containers_get(args)!
|
||||
if res.len > 1 {
|
||||
return ContainerGetError{
|
||||
args: args
|
||||
notfound: true
|
||||
}
|
||||
}
|
||||
return res[0]
|
||||
}
|
||||
|
||||
pub fn (mut self PodmanFactory) container_exists(args ContainerGetArgs) !bool {
|
||||
self.container_get(args) or {
|
||||
if err.code() == 1 {
|
||||
return false
|
||||
}
|
||||
return err
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
pub fn (mut self PodmanFactory) container_delete(args ContainerGetArgs) ! {
|
||||
mut c := self.container_get(args)!
|
||||
c.delete()!
|
||||
self.load()!
|
||||
}
|
||||
|
||||
// remove one or more container
|
||||
pub fn (mut self PodmanFactory) containers_delete(args ContainerGetArgs) ! {
|
||||
mut cs := self.containers_get(args)!
|
||||
for mut c in cs {
|
||||
c.delete()!
|
||||
}
|
||||
self.load()!
|
||||
}
|
||||
|
||||
pub struct ContainerGetError {
|
||||
Error
|
||||
pub:
|
||||
args ContainerGetArgs
|
||||
notfound bool
|
||||
toomany bool
|
||||
}
|
||||
|
||||
pub fn (err ContainerGetError) msg() string {
|
||||
if err.notfound {
|
||||
return 'Could not find image with args:\n${err.args}'
|
||||
}
|
||||
if err.toomany {
|
||||
return 'can not get container, Found more than 1 container with args:\n${err.args}'
|
||||
}
|
||||
panic('unknown error for ContainerGetError')
|
||||
}
|
||||
|
||||
pub fn (err ContainerGetError) code() int {
|
||||
if err.notfound {
|
||||
return 1
|
||||
}
|
||||
if err.toomany {
|
||||
return 2
|
||||
}
|
||||
panic('unknown error for ContainerGetError')
|
||||
}
|
||||
@@ -1,138 +0,0 @@
|
||||
module podman
|
||||
|
||||
import freeflowuniverse.herolib.virt.utils
|
||||
import freeflowuniverse.herolib.osal.core as osal { exec }
|
||||
import time
|
||||
import freeflowuniverse.herolib.ui.console
|
||||
|
||||
pub fn (mut self PodmanFactory) images_load() ! {
|
||||
self.images = []Image{}
|
||||
mut lines := osal.execute_silent("podman images --format '{{.ID}}||{{.Id}}||{{.Repository}}||{{.Tag}}||{{.Digest}}||{{.Size}}||{{.CreatedAt}}'")!
|
||||
for line in lines.split_into_lines() {
|
||||
fields := line.split('||').map(utils.clear_str)
|
||||
if fields.len != 7 {
|
||||
panic('podman image needs to output 7 parts.\n${fields}')
|
||||
}
|
||||
mut image := Image{
|
||||
engine: &self
|
||||
}
|
||||
image.id = fields[0]
|
||||
image.id_full = fields[1]
|
||||
image.repo = fields[2]
|
||||
image.tag = fields[3]
|
||||
image.digest = utils.parse_digest(fields[4]) or { '' }
|
||||
image.size = utils.parse_size_mb(fields[5]) or { 0 }
|
||||
image.created = utils.parse_time(fields[6]) or { time.now() }
|
||||
self.images << image
|
||||
}
|
||||
}
|
||||
|
||||
// import herocontainers image back into the local env
|
||||
pub fn (mut engine PodmanFactory) image_load(path string) ! {
|
||||
exec(cmd: 'podman load < ${path}', stdout: false)!
|
||||
engine.images_load()!
|
||||
}
|
||||
|
||||
@[params]
|
||||
pub struct ImageGetArgs {
|
||||
pub:
|
||||
repo string
|
||||
tag string
|
||||
digest string
|
||||
id string
|
||||
id_full string
|
||||
}
|
||||
|
||||
// find image based on repo and optional tag
|
||||
// args:
|
||||
// repo string
|
||||
// tag string
|
||||
// digest string
|
||||
// id string
|
||||
// id_full
|
||||
pub fn (mut self PodmanFactory) image_get(args ImageGetArgs) !Image {
|
||||
for i in self.images {
|
||||
if args.digest != '' && i.digest == args.digest {
|
||||
return i
|
||||
}
|
||||
if args.id != '' && i.id == args.id {
|
||||
return i
|
||||
}
|
||||
if args.id_full != '' && i.id_full == args.id_full {
|
||||
return i
|
||||
}
|
||||
}
|
||||
|
||||
if args.repo != '' || args.tag != '' {
|
||||
mut counter := 0
|
||||
mut result_digest := ''
|
||||
for i in self.images {
|
||||
if args.repo != '' && i.repo != args.repo {
|
||||
continue
|
||||
}
|
||||
if args.tag != '' && i.tag != args.tag {
|
||||
continue
|
||||
}
|
||||
console.print_debug('found image for get: ${i} -- ${args}')
|
||||
result_digest = i.digest
|
||||
counter += 1
|
||||
}
|
||||
if counter > 1 {
|
||||
return ImageGetError{
|
||||
args: args
|
||||
toomany: true
|
||||
}
|
||||
}
|
||||
return self.image_get(digest: result_digest)!
|
||||
}
|
||||
return ImageGetError{
|
||||
args: args
|
||||
notfound: true
|
||||
}
|
||||
}
|
||||
|
||||
pub fn (mut self PodmanFactory) image_exists(args ImageGetArgs) !bool {
|
||||
self.image_get(args) or {
|
||||
if err.code() == 1 {
|
||||
return false
|
||||
}
|
||||
return err
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
// get buildah containers
|
||||
pub fn (mut self PodmanFactory) images_get() ![]Image {
|
||||
if self.builders.len == 0 {
|
||||
self.images_load()!
|
||||
}
|
||||
return self.images
|
||||
}
|
||||
|
||||
pub fn (err ImageGetError) msg() string {
|
||||
if err.notfound {
|
||||
return 'Could not find image with args:\n${err.args}'
|
||||
}
|
||||
if err.toomany {
|
||||
return 'Found more than 1 image with args:\n${err.args}'
|
||||
}
|
||||
panic('unknown error for ImageGetError')
|
||||
}
|
||||
|
||||
pub fn (err ImageGetError) code() int {
|
||||
if err.notfound {
|
||||
return 1
|
||||
}
|
||||
if err.toomany {
|
||||
return 2
|
||||
}
|
||||
panic('unknown error for ImageGetError')
|
||||
}
|
||||
|
||||
pub struct ImageGetError {
|
||||
Error
|
||||
pub:
|
||||
args ImageGetArgs
|
||||
notfound bool
|
||||
toomany bool
|
||||
}
|
||||
@@ -1,7 +1,22 @@
|
||||
|
||||
# Podman Module
|
||||
|
||||
Tools to work with containers using Podman and Buildah.
|
||||
A clean, consolidated module for working with Podman containers and Buildah builders.
|
||||
|
||||
## Overview
|
||||
|
||||
This module provides **two complementary APIs** for Podman functionality:
|
||||
|
||||
1. **Simple API**: Direct functions for quick operations (`podman.run_container()`, `podman.list_containers()`)
|
||||
2. **Factory API**: Advanced factory pattern for complex workflows and state management
|
||||
|
||||
### Key Features
|
||||
|
||||
- **Container Management**: Create, run, stop, and manage containers
|
||||
- **Image Management**: List, inspect, and manage container images
|
||||
- **Builder Integration**: Seamless Buildah integration for image building
|
||||
- **Unified Error Handling**: Consistent error types across all operations
|
||||
- **Cross-Platform**: Works on Linux and macOS
|
||||
|
||||
## Platform Support
|
||||
|
||||
@@ -9,114 +24,304 @@ Tools to work with containers using Podman and Buildah.
|
||||
- **macOS**: Full support (requires podman installation)
|
||||
- **Windows**: Not supported
|
||||
|
||||
## Basic Usage
|
||||
## Module Structure
|
||||
|
||||
```v
|
||||
#!/usr/bin/env -S v -n -w -enable-globals run
|
||||
- **`factory.v`** - Main entry point with both simple API and factory pattern
|
||||
- **`container.v`** - All container types and management functions
|
||||
- **`image.v`** - All image types and management functions
|
||||
- **`builder.v`** - Buildah integration for image building
|
||||
- **`errors.v`** - Unified error handling system
|
||||
|
||||
import freeflowuniverse.herolib.virt.podman
|
||||
import freeflowuniverse.herolib.ui.console
|
||||
## API Approaches
|
||||
|
||||
console.print_header("PODMAN Demo")
|
||||
### 1. Simple API (Quick Operations)
|
||||
|
||||
// Create a new podman factory
|
||||
// install: true will install podman if not present
|
||||
// herocompile: true will compile hero for use in containers
|
||||
mut factory := podman.new(install: false, herocompile: false)!
|
||||
|
||||
// Create a new builder
|
||||
mut builder := factory.builder_new(name: 'test', from: 'docker.io/ubuntu:latest')!
|
||||
|
||||
// Run commands in the builder
|
||||
builder.run('apt-get update && apt-get install -y curl')!
|
||||
|
||||
// Open interactive shell
|
||||
builder.shell()!
|
||||
```
|
||||
|
||||
## buildah tricks
|
||||
|
||||
```bash
|
||||
#find the containers as have been build, these are the active ones you can work with
|
||||
buildah ls
|
||||
#see the images
|
||||
buildah images
|
||||
```
|
||||
|
||||
result is something like
|
||||
|
||||
```bash
|
||||
CONTAINER ID BUILDER IMAGE ID IMAGE NAME CONTAINER NAME
|
||||
a9946633d4e7 * scratch base
|
||||
86ff0deb00bf * 4feda76296d6 localhost/builder:latest base_go_rust
|
||||
```
|
||||
|
||||
some tricks
|
||||
|
||||
```bash
|
||||
#run interactive in one (here we chose the builderv one)
|
||||
buildah run --terminal --env TERM=xterm base /bin/bash
|
||||
#or
|
||||
buildah run --terminal --env TERM=xterm default /bin/bash
|
||||
#or
|
||||
buildah run --terminal --env TERM=xterm base_go_rust /bin/bash
|
||||
|
||||
```
|
||||
|
||||
to check inside the container about diskusage
|
||||
|
||||
```bash
|
||||
apt install ncdu
|
||||
ncdu
|
||||
```
|
||||
|
||||
## Create Container
|
||||
For simple container operations, use the direct functions:
|
||||
|
||||
```v
|
||||
import freeflowuniverse.herolib.virt.podman
|
||||
import freeflowuniverse.herolib.ui.console
|
||||
|
||||
console.print_header("Create a container")
|
||||
// List containers and images
|
||||
containers := podman.list_containers(true)! // true = include stopped
|
||||
images := podman.list_images()!
|
||||
|
||||
mut factory := podman.new()!
|
||||
// Run a container
|
||||
options := podman.RunOptions{
|
||||
name: 'my-app'
|
||||
detach: true
|
||||
ports: ['8080:80']
|
||||
volumes: ['/data:/app/data']
|
||||
env: {'ENV': 'production'}
|
||||
}
|
||||
container_id := podman.run_container('nginx:latest', options)!
|
||||
|
||||
// Create a container with advanced options
|
||||
// See https://docs.podman.io/en/latest/markdown/podman-run.1.html
|
||||
mut container := factory.container_create(
|
||||
name: 'mycontainer'
|
||||
image_repo: 'ubuntu'
|
||||
image_tag: 'latest'
|
||||
// Resource limits
|
||||
memory: '1g'
|
||||
cpus: 0.5
|
||||
// Network config
|
||||
network: 'bridge'
|
||||
network_aliases: ['myapp', 'api']
|
||||
// DNS config
|
||||
dns_servers: ['8.8.8.8', '8.8.4.4']
|
||||
dns_search: ['example.com']
|
||||
interactive: true // Keep STDIN open
|
||||
mounts: [
|
||||
'type=bind,src=/data,dst=/container/data,ro=true'
|
||||
]
|
||||
volumes: [
|
||||
'/config:/etc/myapp:ro'
|
||||
]
|
||||
published_ports: [
|
||||
'127.0.0.1:8080:80'
|
||||
]
|
||||
// Manage containers
|
||||
podman.stop_container(container_id)!
|
||||
podman.remove_container(container_id, force: true)!
|
||||
podman.remove_image('nginx:latest', force: false)!
|
||||
```
|
||||
|
||||
### 2. Factory API (Advanced Workflows)
|
||||
|
||||
For complex operations and state management, use the factory pattern:
|
||||
|
||||
```v
|
||||
import freeflowuniverse.herolib.virt.podman
|
||||
|
||||
// Create factory (with auto-install)
|
||||
mut factory := podman.new(install: true, herocompile: false)!
|
||||
|
||||
// Create containers with advanced options
|
||||
container := factory.container_create(
|
||||
name: 'web-server'
|
||||
image_repo: 'nginx'
|
||||
image_tag: 'alpine'
|
||||
forwarded_ports: ['80:8080']
|
||||
memory: '512m'
|
||||
cpus: 1.0
|
||||
)!
|
||||
|
||||
// Start the container
|
||||
container.start()!
|
||||
// Build images with Buildah
|
||||
mut builder := factory.builder_new(
|
||||
name: 'my-app'
|
||||
from: 'ubuntu:latest'
|
||||
)!
|
||||
builder.run('apt-get update && apt-get install -y nodejs')!
|
||||
builder.copy('./app', '/usr/src/app')!
|
||||
builder.set_entrypoint('node /usr/src/app/server.js')!
|
||||
builder.commit('my-app:latest')!
|
||||
|
||||
// Execute commands in the container
|
||||
container.execute('apt-get update', false)!
|
||||
|
||||
// Open interactive shell
|
||||
container.shell()!
|
||||
// Seamless integration: build with buildah, run with podman
|
||||
app_container_id := factory.create_from_buildah_image('my-app:latest', config)!
|
||||
```
|
||||
|
||||
## future
|
||||
## Container Operations
|
||||
|
||||
should make this module compatible with <https://github.com/containerd/nerdctl>
|
||||
### Simple Container Management
|
||||
|
||||
```v
|
||||
// List containers
|
||||
all_containers := podman.list_containers(true)! // Include stopped
|
||||
running_containers := podman.list_containers(false)! // Only running
|
||||
|
||||
// Inspect container details
|
||||
container_info := podman.inspect_container('container_id')!
|
||||
println('Container status: ${container_info.status}')
|
||||
|
||||
// Container lifecycle
|
||||
podman.stop_container('container_id')!
|
||||
podman.remove_container('container_id', force: true)!
|
||||
```
|
||||
|
||||
### Advanced Container Creation
|
||||
|
||||
```v
|
||||
// Factory approach with full configuration
|
||||
mut factory := podman.new()!
|
||||
|
||||
container := factory.container_create(
|
||||
name: 'web-app'
|
||||
image_repo: 'nginx'
|
||||
image_tag: 'alpine'
|
||||
|
||||
// Resource limits
|
||||
memory: '1g'
|
||||
cpus: 2.0
|
||||
|
||||
// Networking
|
||||
forwarded_ports: ['80:8080', '443:8443']
|
||||
network: 'bridge'
|
||||
|
||||
// Storage
|
||||
mounted_volumes: ['/data:/app/data:ro', '/logs:/var/log']
|
||||
|
||||
// Environment
|
||||
env: {'NODE_ENV': 'production', 'PORT': '8080'}
|
||||
|
||||
// Runtime options
|
||||
detach: true
|
||||
remove_when_done: false
|
||||
)!
|
||||
```
|
||||
|
||||
## Image Operations
|
||||
|
||||
### Simple Image Management
|
||||
|
||||
```v
|
||||
// List all images
|
||||
images := podman.list_images()!
|
||||
for image in images {
|
||||
println('${image.repository}:${image.tag} - ${image.size}')
|
||||
}
|
||||
|
||||
// Remove images
|
||||
podman.remove_image('nginx:latest', force: false)!
|
||||
podman.remove_image('old-image:v1.0', force: true)! // Force removal
|
||||
```
|
||||
|
||||
### Factory Image Management
|
||||
|
||||
```v
|
||||
mut factory := podman.new()!
|
||||
|
||||
// Load and inspect images
|
||||
factory.images_load()! // Refresh image cache
|
||||
images := factory.images_get()!
|
||||
|
||||
// Find specific images
|
||||
image := factory.image_get(repo: 'nginx', tag: 'latest')!
|
||||
println('Image ID: ${image.id}')
|
||||
|
||||
// Check if image exists
|
||||
if factory.image_exists(repo: 'my-app', tag: 'v1.0')! {
|
||||
println('Image exists')
|
||||
}
|
||||
```
|
||||
|
||||
## Builder Integration (Buildah)
|
||||
|
||||
### Creating and Using Builders
|
||||
|
||||
```v
|
||||
mut factory := podman.new()!
|
||||
|
||||
// Create a builder
|
||||
mut builder := factory.builder_new(
|
||||
name: 'my-app-builder'
|
||||
from: 'ubuntu:22.04'
|
||||
delete: true // Remove existing builder with same name
|
||||
)!
|
||||
|
||||
// Build operations
|
||||
builder.run('apt-get update && apt-get install -y nodejs npm')!
|
||||
builder.copy('./package.json', '/app/')!
|
||||
builder.run('cd /app && npm install')!
|
||||
builder.copy('./src', '/app/src')!
|
||||
|
||||
// Configure the image
|
||||
builder.set_workingdir('/app')!
|
||||
builder.set_entrypoint('node src/server.js')!
|
||||
|
||||
// Commit to image (automatically available in podman)
|
||||
builder.commit('my-app:latest')!
|
||||
|
||||
// Use the built image immediately with podman
|
||||
container_id := factory.create_from_buildah_image('my-app:latest', config)!
|
||||
```
|
||||
|
||||
### Build-to-Run Workflow
|
||||
|
||||
```v
|
||||
// Complete workflow: build with buildah, run with podman
|
||||
container_id := factory.build_and_run_workflow(
|
||||
build_config: build_config,
|
||||
run_config: run_config,
|
||||
image_name: 'my-app'
|
||||
)!
|
||||
```
|
||||
|
||||
## Error Handling
|
||||
|
||||
The module provides comprehensive error handling with specific error types:
|
||||
|
||||
```v
|
||||
// Simple API error handling
|
||||
containers := podman.list_containers(true) or {
|
||||
match err {
|
||||
podman.ContainerError {
|
||||
println('Container operation failed: ${err.msg()}')
|
||||
}
|
||||
podman.ImageError {
|
||||
println('Image operation failed: ${err.msg()}')
|
||||
}
|
||||
else {
|
||||
println('Unexpected error: ${err.msg()}')
|
||||
}
|
||||
}
|
||||
[]podman.PodmanContainer{}
|
||||
}
|
||||
|
||||
// Factory API error handling
|
||||
mut factory := podman.new() or {
|
||||
println('Failed to create factory: ${err}')
|
||||
exit(1)
|
||||
}
|
||||
|
||||
container := factory.container_create(args) or {
|
||||
if err is podman.ContainerError {
|
||||
println('Container creation failed: ${err.msg()}')
|
||||
} else if err is podman.ImageError {
|
||||
println('Image error: ${err.msg()}')
|
||||
} else {
|
||||
println('Creation failed: ${err.msg()}')
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// Builder error handling
|
||||
mut builder := factory.builder_new(name: 'test', from: 'nonexistent:latest') or {
|
||||
println('Builder creation failed: ${err.msg()}')
|
||||
return
|
||||
}
|
||||
|
||||
builder.run('invalid_command') or {
|
||||
println('Command execution failed: ${err.msg()}')
|
||||
// Continue with fallback or cleanup
|
||||
}
|
||||
```
|
||||
|
||||
## Installation and Setup
|
||||
|
||||
```v
|
||||
import freeflowuniverse.herolib.virt.podman
|
||||
|
||||
// Automatic installation
|
||||
mut factory := podman.new(install: true)! // Will install podman if needed
|
||||
|
||||
// Manual installation check
|
||||
mut factory := podman.new(install: false) or {
|
||||
println('Podman not found. Please install podman first.')
|
||||
exit(1)
|
||||
}
|
||||
```
|
||||
|
||||
## Complete Example
|
||||
|
||||
See `examples/virt/podman/podman.vsh` for a comprehensive example that demonstrates:
|
||||
|
||||
- Automatic podman installation
|
||||
- Simple API usage (run_container, list_containers, etc.)
|
||||
- Factory API usage (advanced container creation, builder workflows)
|
||||
- Error handling patterns
|
||||
- Integration between buildah and podman
|
||||
- Cleanup and uninstallation
|
||||
|
||||
## API Reference
|
||||
|
||||
### Simple API Functions
|
||||
|
||||
- `run_container(image, options)` - Run a container with simple options
|
||||
- `list_containers(all)` - List containers (all=true includes stopped)
|
||||
- `list_images()` - List all available images
|
||||
- `inspect_container(id)` - Get detailed container information
|
||||
- `stop_container(id)` - Stop a running container
|
||||
- `remove_container(id, force)` - Remove a container
|
||||
- `remove_image(id, force)` - Remove an image
|
||||
|
||||
### Factory API Methods
|
||||
|
||||
- `new(install, herocompile)` - Create a new PodmanFactory
|
||||
- `container_create(args)` - Create container with advanced options
|
||||
- `create_from_buildah_image(image, config)` - Run container from buildah image
|
||||
- `build_and_run_workflow(build_config, run_config, image_name)` - Complete workflow
|
||||
- `builder_new(name, from)` - Create a new buildah builder
|
||||
- `load()` - Refresh factory state (containers, images, builders)
|
||||
- `reset_all()` - Remove all containers, images, and builders (CAREFUL!)
|
||||
|
||||
## Future Enhancements
|
||||
|
||||
- **nerdctl compatibility**: Make module compatible with [nerdctl](https://github.com/containerd/nerdctl)
|
||||
- **Docker compatibility**: Add Docker runtime support
|
||||
- **Kubernetes integration**: Support for pod and deployment management
|
||||
- **Registry operations**: Enhanced image push/pull capabilities
|
||||
|
||||
@@ -1,128 +0,0 @@
|
||||
module utils
|
||||
|
||||
import time
|
||||
import freeflowuniverse.herolib.ui.console
|
||||
|
||||
pub enum ContainerStatus {
|
||||
up
|
||||
down
|
||||
restarting
|
||||
paused
|
||||
dead
|
||||
created
|
||||
}
|
||||
|
||||
pub struct ContainerVolume {
|
||||
src string
|
||||
dest string
|
||||
}
|
||||
|
||||
// convert strings as used by format from docker to MB in int
|
||||
pub fn parse_size_mb(size_ string) !int {
|
||||
mut size := size_.to_lower()
|
||||
if size.contains('(') {
|
||||
size = size.split('(')[0].trim(' ')
|
||||
}
|
||||
mut s := 0
|
||||
if size.ends_with('gb') {
|
||||
s = size.replace('gb', '').int() * 1024
|
||||
} else if size.ends_with('mb') {
|
||||
s = size.replace('mb', '').int()
|
||||
} else if size.ends_with('kb') {
|
||||
s = int(size.replace('kb', '').f64() / 1000)
|
||||
} else if size.ends_with('b') {
|
||||
s = int(size.replace('b', '').f64() / 1000000)
|
||||
} else {
|
||||
panic("@TODO for other sizes, '${size}'")
|
||||
}
|
||||
return s
|
||||
}
|
||||
|
||||
pub fn parse_digest(s string) !string {
|
||||
mut s2 := s
|
||||
if s.starts_with('sha256:') {
|
||||
s2 = s2[7..]
|
||||
}
|
||||
return s2
|
||||
}
|
||||
|
||||
pub fn parse_time(s string) !time.Time {
|
||||
mut s2 := s
|
||||
s3 := s2.split('+')[0].trim(' ')
|
||||
return time.parse_iso8601(s3)
|
||||
}
|
||||
|
||||
pub fn parse_ports(s string) ![]string {
|
||||
s3 := s.split(',').map(clear_str)
|
||||
return s3
|
||||
}
|
||||
|
||||
pub fn parse_labels(s string) !map[string]string {
|
||||
mut res := map[string]string{}
|
||||
if s.trim_space().len > 0 {
|
||||
// console.print_debug(s)
|
||||
// panic("todo")
|
||||
// TODO: need to do
|
||||
}
|
||||
return res
|
||||
}
|
||||
|
||||
pub fn parse_networks(s string) ![]string {
|
||||
mut res := []string{}
|
||||
if s.trim_space().len > 0 {
|
||||
// console.print_debug(s)
|
||||
// panic("todo networks")
|
||||
// TODO: need to do
|
||||
}
|
||||
return res
|
||||
}
|
||||
|
||||
pub fn parse_mounts(s string) ![]ContainerVolume {
|
||||
mut res := []ContainerVolume{}
|
||||
// TODO: need to do
|
||||
if s.trim_space().len > 0 {
|
||||
// console.print_debug(s)
|
||||
// panic("todo mounts")
|
||||
// TODO: need to do
|
||||
}
|
||||
return res
|
||||
}
|
||||
|
||||
pub fn parse_container_state(state string) !ContainerStatus {
|
||||
if state.contains('Dead:true') || state.contains('dead') {
|
||||
return ContainerStatus.dead
|
||||
}
|
||||
if state.contains('Paused:true') || state.contains('paused') {
|
||||
return ContainerStatus.paused
|
||||
}
|
||||
if state.contains('Restarting:true') || state.contains('restarting') {
|
||||
return ContainerStatus.restarting
|
||||
}
|
||||
if state.contains('Running:true') || state.contains('running') {
|
||||
return ContainerStatus.up
|
||||
}
|
||||
if state.contains('Status:created') || state.contains('created') {
|
||||
return ContainerStatus.created
|
||||
}
|
||||
if state.contains('exited') {
|
||||
return ContainerStatus.down
|
||||
}
|
||||
if state.contains('stopped') {
|
||||
return ContainerStatus.down
|
||||
}
|
||||
return error('Could not find herocontainers container status: ${state}')
|
||||
}
|
||||
|
||||
pub fn clear_str(s string) string {
|
||||
return s.trim(' \n\t')
|
||||
}
|
||||
|
||||
pub fn contains_ssh_port(forwarded_ports []string) bool {
|
||||
for port in forwarded_ports {
|
||||
splitted := port.split(':')
|
||||
if splitted.last() == '22' || splitted.last() == '22/tcp' {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
@@ -1,5 +0,0 @@
|
||||
module docker
|
||||
|
||||
fn test_contains_ssh_port() {
|
||||
assert contains_ssh_port(['20001:22'])
|
||||
}
|
||||
Reference in New Issue
Block a user