github.com/hanks177/podman/v4@v4.1.3-0.20220613032544-16d90015bc83/pkg/bindings/system/system.go (about)

     1  package system
     2  
     3  import (
     4  	"context"
     5  	"encoding/json"
     6  	"fmt"
     7  	"io"
     8  	"net/http"
     9  	"time"
    10  
    11  	"github.com/hanks177/podman/v4/libpod/define"
    12  	"github.com/hanks177/podman/v4/pkg/bindings"
    13  	"github.com/hanks177/podman/v4/pkg/domain/entities"
    14  	"github.com/pkg/errors"
    15  	"github.com/sirupsen/logrus"
    16  )
    17  
    18  // Events allows you to monitor libdpod related events like container creation and
    19  // removal.  The events are then passed to the eventChan provided. The optional cancelChan
    20  // can be used to cancel the read of events and close down the HTTP connection.
    21  func Events(ctx context.Context, eventChan chan entities.Event, cancelChan chan bool, options *EventsOptions) error {
    22  	conn, err := bindings.GetClient(ctx)
    23  	if err != nil {
    24  		return err
    25  	}
    26  	params, err := options.ToParams()
    27  	if err != nil {
    28  		return err
    29  	}
    30  	response, err := conn.DoRequest(ctx, nil, http.MethodGet, "/events", params, nil)
    31  	if err != nil {
    32  		return err
    33  	}
    34  	defer response.Body.Close()
    35  
    36  	if cancelChan != nil {
    37  		go func() {
    38  			<-cancelChan
    39  			err = response.Body.Close()
    40  			logrus.Error(errors.Wrap(err, "unable to close event response body"))
    41  		}()
    42  	}
    43  
    44  	dec := json.NewDecoder(response.Body)
    45  	for err = (error)(nil); err == nil; {
    46  		var e = entities.Event{}
    47  		err = dec.Decode(&e)
    48  		if err == nil {
    49  			eventChan <- e
    50  		}
    51  	}
    52  	close(eventChan)
    53  	switch {
    54  	case err == nil:
    55  		return nil
    56  	case errors.Is(err, io.EOF):
    57  		return nil
    58  	default:
    59  		return errors.Wrap(err, "unable to decode event response")
    60  	}
    61  }
    62  
    63  // Prune removes all unused system data.
    64  func Prune(ctx context.Context, options *PruneOptions) (*entities.SystemPruneReport, error) {
    65  	var (
    66  		report entities.SystemPruneReport
    67  	)
    68  	conn, err := bindings.GetClient(ctx)
    69  	if err != nil {
    70  		return nil, err
    71  	}
    72  	params, err := options.ToParams()
    73  	if err != nil {
    74  		return nil, err
    75  	}
    76  	response, err := conn.DoRequest(ctx, nil, http.MethodPost, "/system/prune", params, nil)
    77  	if err != nil {
    78  		return nil, err
    79  	}
    80  	defer response.Body.Close()
    81  
    82  	return &report, response.Process(&report)
    83  }
    84  
    85  func Version(ctx context.Context, options *VersionOptions) (*entities.SystemVersionReport, error) {
    86  	var (
    87  		component entities.ComponentVersion
    88  		report    entities.SystemVersionReport
    89  	)
    90  	if options == nil {
    91  		options = new(VersionOptions)
    92  	}
    93  	_ = options
    94  	version, err := define.GetVersion()
    95  	if err != nil {
    96  		return nil, err
    97  	}
    98  	report.Client = &version
    99  
   100  	conn, err := bindings.GetClient(ctx)
   101  	if err != nil {
   102  		return nil, err
   103  	}
   104  	response, err := conn.DoRequest(ctx, nil, http.MethodGet, "/version", nil, nil)
   105  	if err != nil {
   106  		return nil, err
   107  	}
   108  	defer response.Body.Close()
   109  
   110  	if err = response.Process(&component); err != nil {
   111  		return nil, err
   112  	}
   113  
   114  	b, _ := time.Parse(time.RFC3339, component.BuildTime)
   115  	report.Server = &define.Version{
   116  		APIVersion: component.APIVersion,
   117  		Version:    component.Version.Version,
   118  		GoVersion:  component.GoVersion,
   119  		GitCommit:  component.GitCommit,
   120  		BuiltTime:  time.Unix(b.Unix(), 0).Format(time.ANSIC),
   121  		Built:      b.Unix(),
   122  		OsArch:     fmt.Sprintf("%s/%s", component.Os, component.Arch),
   123  		Os:         component.Os,
   124  	}
   125  
   126  	for _, c := range component.Components {
   127  		if c.Name == "Podman Engine" {
   128  			report.Server.APIVersion = c.Details["APIVersion"]
   129  		}
   130  	}
   131  	return &report, err
   132  }
   133  
   134  // DiskUsage returns information about image, container, and volume disk
   135  // consumption
   136  func DiskUsage(ctx context.Context, options *DiskOptions) (*entities.SystemDfReport, error) {
   137  	var report entities.SystemDfReport
   138  	if options == nil {
   139  		options = new(DiskOptions)
   140  	}
   141  	_ = options
   142  	conn, err := bindings.GetClient(ctx)
   143  	if err != nil {
   144  		return nil, err
   145  	}
   146  	response, err := conn.DoRequest(ctx, nil, http.MethodGet, "/system/df", nil, nil)
   147  	if err != nil {
   148  		return nil, err
   149  	}
   150  	defer response.Body.Close()
   151  
   152  	return &report, response.Process(&report)
   153  }