func (id *InventoryDataRunner) Get() (client.InventoryData, error) {
tools, err := listRunnable(id.dir)
if err != nil {
return nil, errors.Wrapf(err, "failed to list tools for inventory data")
}
idec := NewInventoryDataDecoder()
for _, t := range tools {
cmd := id.cmd.Command(t)
out, err := cmd.StdoutPipe()
if err != nil {
log.Errorf("failed to open stdout for inventory tool %s: %v", t, err)
continue
}
if err := cmd.Start(); err != nil {
log.Errorf("inventory tool %s failed with status: %v", t, err)
continue
}
p := utils.KeyValParser{}
if err := p.Parse(out); err != nil {
log.Warnf("inventory tool %s returned unparsable output: %v", t, err)
continue
}
if err := cmd.Wait(); err != nil {
log.Warnf("inventory tool %s wait failed: %v", t, err)
}
idec.AppendFromRaw(p.Collect())
}
return idec.GetInventoryData(), nil
}
func newHttpsClient(conf Config) (*http.Client, error) {
client := newHttpClient()
trustedcerts, err := loadServerTrust(conf)
if err != nil {
return nil, errors.Wrapf(err, "cannot initialize server trust")
}
clientcerts, err := loadClientCert(conf)
if err != nil {
return nil, errors.Wrapf(err, "can not load client certificate")
}
if conf.NoVerify {
log.Warnf("certificate verification skipped..")
}
tlsc := tls.Config{
RootCAs: trustedcerts,
InsecureSkipVerify: conf.NoVerify,
}
transport := http.Transport{
TLSClientConfig: &tlsc,
}
if clientcerts != nil {
transport.TLSClientConfig.Certificates = []tls.Certificate{*clientcerts}
}
client.Transport = &transport
return client, nil
}
func (iu *InventoryUpdateState) Handle(ctx *StateContext, c Controller) (State, bool) {
err := c.InventoryRefresh()
if err != nil {
log.Warnf("failed to refresh inventory: %v", err)
} else {
log.Debugf("inventory refresh complete")
}
return updateCheckWaitState, false
}
func parseLogFlags(args logOptionsType) error {
var logOptCount int
if *args.logLevel != "" {
level, err := log.ParseLevel(*args.logLevel)
if err != nil {
return err
}
log.SetLevel(level)
logOptCount++
}
if *args.info {
log.SetLevel(log.InfoLevel)
logOptCount++
}
if *args.debug {
log.SetLevel(log.DebugLevel)
logOptCount++
}
if logOptCount > 1 {
return errMsgIncompatibleLogOptions
} else if logOptCount == 0 {
// set info as a default log level
log.SetLevel(log.InfoLevel)
}
if *args.logFile != "" {
fd, err := os.Create(*args.logFile)
if err != nil {
return err
}
log.SetOutput(fd)
}
if *args.logModules != "" {
modules := strings.Split(*args.logModules, ",")
log.SetModuleFilter(modules)
}
if !*args.noSyslog {
if err := log.AddSyslogHook(); err != nil {
log.Warnf("Could not connect to syslog daemon: %s. "+
"(use -no-syslog to disable completely)",
err.Error())
}
}
return nil
}
// Client initialization
func New(conf Config) (*ApiClient, error) {
var client *http.Client
if conf == (Config{}) {
client = newHttpClient()
} else {
var err error
client, err = newHttpsClient(conf)
if err != nil {
return nil, err
}
}
if client.Transport == nil {
client.Transport = &http.Transport{}
}
if err := http2.ConfigureTransport(client.Transport.(*http.Transport)); err != nil {
log.Warnf("failed to enable HTTP/2 for client: %v", err)
}
return &ApiClient{*client}, nil
}
func argsParse(args []string) (runOptionsType, error) {
var runOptions runOptionsType
parsing := flag.NewFlagSet("mender", flag.ContinueOnError)
// FLAGS ---------------------------------------------------------------
committing := parsing.Bool("commit", false, "Commit current update.")
debug := parsing.Bool("debug", false, "Debug log level. This is a "+
"shorthand for '-l debug'.")
info := parsing.Bool("info", false, "Info log level. This is a "+
"shorthand for '-l info'.")
imageFile := parsing.String("rootfs", "",
"Root filesystem URI to use for update. Can be either a local "+
"file or a URL.")
logLevel := parsing.String("log-level", "", "Log level, which can be "+
"'debug', 'info', 'warning', 'error', 'fatal' or 'panic'. "+
"Earlier log levels will also log the subsequent levels (so "+
"'debug' will log everything). The default log level is "+
"'warning'.")
logModules := parsing.String("log-modules", "", "Filter logging by "+
"module. This is a comma separated list of modules to log, "+
"other modules will be omitted. To see which modules are "+
"available, take a look at a non-filtered log and select "+
"the modules appropriate for you.")
noSyslog := parsing.Bool("no-syslog", false, "Disable logging to "+
"syslog. Note that debug message are never logged to syslog.")
logFile := parsing.String("log-file", "", "File to log to.")
// PARSING -------------------------------------------------------------
if err := parsing.Parse(args); err != nil {
return runOptions, err
}
// FLAG LOGIC ----------------------------------------------------------
var logOptCount int = 0
if *logLevel != "" {
level, err := log.ParseLevel(*logLevel)
if err != nil {
return runOptions, err
}
log.SetLevel(level)
logOptCount += 1
}
if *info {
log.SetLevel(log.InfoLevel)
logOptCount += 1
}
if *debug {
log.SetLevel(log.DebugLevel)
logOptCount += 1
}
if logOptCount > 1 {
return runOptions, errMsgIncompatibleLogOptions
} else if logOptCount == 0 {
// Default log level.
log.SetLevel(log.WarnLevel)
}
if *logFile != "" {
fd, err := os.Create(*logFile)
if err != nil {
return runOptions, err
}
log.SetOutput(fd)
}
if *logModules != "" {
modules := strings.Split(*logModules, ",")
log.SetModuleFilter(modules)
}
if !*noSyslog {
if err := log.AddSyslogHook(); err != nil {
log.Warnf("Could not connect to syslog daemon: %s. "+
"(use -no-syslog to disable completely)",
err.Error())
}
}
if *imageFile == "" && !*committing {
return runOptions, errMsgNoArgumentsGiven
}
runOptions.imageFile = *imageFile
runOptions.committing = *committing
return runOptions, nil
}