// Creates a cAdvisor and exports its API on the specified port if port > 0. func New(port uint) (Interface, error) { sysFs, err := sysfs.NewRealSysFs() if err != nil { return nil, err } // Create and start the cAdvisor container manager. m, err := manager.New(memory.New(statsCacheDuration, nil), sysFs) if err != nil { return nil, err } cadvisorClient := &cadvisorClient{ Manager: m, } // Export the HTTP endpoint if a port was specified. if port > 0 { err = cadvisorClient.exportHTTP(port) if err != nil { return nil, err } } return cadvisorClient, nil }
// Creates a cAdvisor and exports its API on the specified port if port > 0. func New(backendStorageName string, port uint) (Interface, error) { backendStorage, err := NewBackendStorage(backendStorageName) if err != nil { glog.Fatalf("Failed to connect to database: %s", err) } sysFs, err := sysfs.NewRealSysFs() if err != nil { return nil, err } // Create and start the cAdvisor container manager. m, err := manager.New(memory.New(statsCacheDuration, backendStorage), sysFs, maxHousekeepingInterval, allowDynamicHousekeeping, cadvisorMetrics.MetricSet{cadvisorMetrics.NetworkTcpUsageMetrics: struct{}{}}) if err != nil { return nil, err } cadvisorClient := &cadvisorClient{ Manager: m, } err = cadvisorClient.exportHTTP(port) if err != nil { return nil, err } return cadvisorClient, nil }
func GetNetworkStats(name string) (info.InterfaceStats, error) { // TODO(rjnagal): Take syfs as an argument. sysFs, err := sysfs.NewRealSysFs() if err != nil { return info.InterfaceStats{}, err } return getNetworkStats(name, sysFs) }
func main() { defer glog.Flush() flag.Parse() if *versionFlag { fmt.Printf("cAdvisor version %s (%s)\n", version.Info["version"], version.Info["revision"]) os.Exit(0) } setMaxProcs() memoryStorage, err := NewMemoryStorage() if err != nil { glog.Fatalf("Failed to initialize storage driver: %s", err) } sysFs, err := sysfs.NewRealSysFs() if err != nil { glog.Fatalf("Failed to create a system interface: %s", err) } collectorHttpClient := createCollectorHttpClient(*collectorCert, *collectorKey) containerManager, err := manager.New(memoryStorage, sysFs, *maxHousekeepingInterval, *allowDynamicHousekeeping, ignoreMetrics.MetricSet, &collectorHttpClient) if err != nil { glog.Fatalf("Failed to create a Container Manager: %s", err) } mux := http.NewServeMux() if *enableProfiling { mux.HandleFunc("/debug/pprof/", pprof.Index) mux.HandleFunc("/debug/pprof/cmdline", pprof.Cmdline) mux.HandleFunc("/debug/pprof/profile", pprof.Profile) mux.HandleFunc("/debug/pprof/symbol", pprof.Symbol) } // Register all HTTP handlers. err = cadvisorhttp.RegisterHandlers(mux, containerManager, *httpAuthFile, *httpAuthRealm, *httpDigestFile, *httpDigestRealm) if err != nil { glog.Fatalf("Failed to register HTTP handlers: %v", err) } cadvisorhttp.RegisterPrometheusHandler(mux, containerManager, *prometheusEndpoint, nil) // Start the manager. if err := containerManager.Start(); err != nil { glog.Fatalf("Failed to start container manager: %v", err) } // Install signal handler. installSignalHandler(containerManager) glog.Infof("Starting cAdvisor version: %s-%s on port %d", version.Info["version"], version.Info["revision"], *argPort) addr := fmt.Sprintf("%s:%d", *argIp, *argPort) glog.Fatal(http.ListenAndServe(addr, mux)) }
func main() { defer glog.Flush() flag.Parse() if *versionFlag { fmt.Printf("cAdvisor version %s (%s)\n", version.Info["version"], version.Info["revision"]) os.Exit(0) } setMaxProcs() memoryStorage, err := NewMemoryStorage(*argDbDriver) if err != nil { glog.Fatalf("Failed to connect to database: %s", err) } sysFs, err := sysfs.NewRealSysFs() if err != nil { glog.Fatalf("Failed to create a system interface: %s", err) } containerManager, err := manager.New(memoryStorage, sysFs, *maxHousekeepingInterval, *allowDynamicHousekeeping) if err != nil { glog.Fatalf("Failed to create a Container Manager: %s", err) } mux := http.DefaultServeMux handler := cors.Default().Handler(mux) // Register all HTTP handlers. err = cadvisorHttp.RegisterHandlers(mux, containerManager, *httpAuthFile, *httpAuthRealm, *httpDigestFile, *httpDigestRealm) if err != nil { glog.Fatalf("Failed to register HTTP handlers: %v", err) } cadvisorHttp.RegisterPrometheusHandler(mux, containerManager, *prometheusEndpoint, nil) // Start the manager. if err := containerManager.Start(); err != nil { glog.Fatalf("Failed to start container manager: %v", err) } // Install signal handler. installSignalHandler(containerManager) glog.Infof("Starting cAdvisor version: %s-%s on port %d", version.Info["version"], version.Info["revision"], *argPort) addr := fmt.Sprintf("%s:%d", *argIp, *argPort) glog.Fatal(http.ListenAndServe(addr, handler)) }
func main() { defer glog.Flush() flag.Parse() if *versionFlag { fmt.Printf("cAdvisor version %s\n", version.VERSION) os.Exit(0) } setMaxProcs() memoryStorage, err := NewMemoryStorage(*argDbDriver) if err != nil { glog.Fatalf("Failed to connect to database: %s", err) } sysFs, err := sysfs.NewRealSysFs() if err != nil { glog.Fatalf("Failed to create a system interface: %s", err) } containerManager, err := manager.New(memoryStorage, sysFs) if err != nil { glog.Fatalf("Failed to create a Container Manager: %s", err) } mux := http.DefaultServeMux // Register all HTTP handlers. err = cadvisorHttp.RegisterHandlers(mux, containerManager, *httpAuthFile, *httpAuthRealm, *httpDigestFile, *httpDigestRealm, *prometheusEndpoint) if err != nil { glog.Fatalf("Failed to register HTTP handlers: %v", err) } // Start the manager. if err := containerManager.Start(); err != nil { glog.Fatalf("Failed to start container manager: %v", err) } // Install signal handler. installSignalHandler(containerManager) glog.Infof("Starting cAdvisor version: %q on port %d", version.VERSION, *argPort) addr := fmt.Sprintf("%s:%d", *argIp, *argPort) fmt.Println("------address-----------") fmt.Println(addr) glog.Fatal(http.ListenAndServe(addr, nil)) }
func initContainerManager() { sysFs, err := sysfs.NewRealSysFs() if err != nil { log.Infof("stats: failed to create a system interface (%v)", err) return } // TODO: support influxdb or other backend storage cmgr, err = manager.New(memory.New(storageDuration, nil), sysFs) if err != nil { log.Infof("stats: failed to create a container Manager (%v)", err) return } if err := cmgr.Start(); err != nil { log.Infof("stats: failed to start container manager (%v)", err) return } }
// Creates a cAdvisor and exports its API on the specified port if port > 0. func New(port uint) (Interface, error) { sysFs, err := sysfs.NewRealSysFs() if err != nil { return nil, err } // Create and start the cAdvisor container manager. m, err := manager.New(memory.New(statsCacheDuration, nil), sysFs, maxHousekeepingInterval, allowDynamicHousekeeping) if err != nil { return nil, err } cadvisorClient := &cadvisorClient{ Manager: m, } err = cadvisorClient.exportHTTP(port) if err != nil { return nil, err } return cadvisorClient, nil }
// Creates a cAdvisor and exports its API on the specified port if port > 0. func New(port uint, runtime string) (Interface, error) { sysFs, err := sysfs.NewRealSysFs() if err != nil { return nil, err } // Create and start the cAdvisor container manager. m, err := manager.New(memory.New(statsCacheDuration, nil), sysFs, maxHousekeepingInterval, allowDynamicHousekeeping, cadvisorMetrics.MetricSet{cadvisorMetrics.NetworkTcpUsageMetrics: struct{}{}}) if err != nil { return nil, err } cadvisorClient := &cadvisorClient{ runtime: runtime, Manager: m, } err = cadvisorClient.exportHTTP(port) if err != nil { return nil, err } return cadvisorClient, nil }
func main() { defer glog.Flush() flag.Parse() if *versionFlag { fmt.Printf("cAdvisor version %s\n", info.VERSION) os.Exit(0) } setMaxProcs() storageDriver, err := NewStorageDriver(*argDbDriver) if err != nil { glog.Fatalf("Failed to connect to database: %s", err) } sysFs, err := sysfs.NewRealSysFs() if err != nil { glog.Fatalf("Failed to create a system interface: %s", err) } containerManager, err := manager.New(storageDriver, sysFs) if err != nil { glog.Fatalf("Failed to create a Container Manager: %s", err) } // Register Docker. if err := docker.Register(containerManager); err != nil { glog.Errorf("Docker registration failed: %v.", err) } // Register the raw driver. if err := raw.Register(containerManager); err != nil { glog.Fatalf("Raw registration failed: %v.", err) } // Basic health handler. if err := healthz.RegisterHandler(); err != nil { glog.Fatalf("Failed to register healthz handler: %s", err) } // Validation/Debug handler. http.HandleFunc(validate.ValidatePage, func(w http.ResponseWriter, r *http.Request) { err := validate.HandleRequest(w, containerManager) if err != nil { fmt.Fprintf(w, "%s", err) } }) // Register API handler. if err := api.RegisterHandlers(containerManager); err != nil { glog.Fatalf("Failed to register API handlers: %s", err) } // Redirect / to containers page. http.Handle("/", http.RedirectHandler(pages.ContainersPage, http.StatusTemporaryRedirect)) var authenticated bool = false // Setup the authenticator object if *httpAuthFile != "" { glog.Infof("Using auth file %s", *httpAuthFile) secrets := auth.HtpasswdFileProvider(*httpAuthFile) authenticator := auth.NewBasicAuthenticator(*httpAuthRealm, secrets) http.HandleFunc(static.StaticResource, authenticator.Wrap(staticHandler)) if err := pages.RegisterHandlersBasic(containerManager, authenticator); err != nil { glog.Fatalf("Failed to register pages auth handlers: %s", err) } authenticated = true } if *httpAuthFile == "" && *httpDigestFile != "" { glog.Infof("Using digest file %s", *httpDigestFile) secrets := auth.HtdigestFileProvider(*httpDigestFile) authenticator := auth.NewDigestAuthenticator(*httpDigestRealm, secrets) http.HandleFunc(static.StaticResource, authenticator.Wrap(staticHandler)) if err := pages.RegisterHandlersDigest(containerManager, authenticator); err != nil { glog.Fatalf("Failed to register pages digest handlers: %s", err) } authenticated = true } // Change handler based on authenticator initalization if !authenticated { http.HandleFunc(static.StaticResource, staticHandlerNoAuth) if err := pages.RegisterHandlersBasic(containerManager, nil); err != nil { glog.Fatalf("Failed to register pages handlers: %s", err) } } // Start the manager. if err := containerManager.Start(); err != nil { glog.Fatalf("Failed to start container manager: %v", err) } // Install signal handler. installSignalHandler(containerManager) glog.Infof("Starting cAdvisor version: %q on port %d", info.VERSION, *argPort) addr := fmt.Sprintf("%s:%d", *argIp, *argPort) glog.Fatal(http.ListenAndServe(addr, nil)) }