func ProjectPort(p *project.Project, c *cli.Context) { if len(c.Args()) != 2 { logrus.Fatalf("Please pass arguments in the form: SERVICE PORT") } index := c.Int("index") protocol := c.String("protocol") service, err := p.CreateService(c.Args()[0]) if err != nil { logrus.Fatal(err) } containers, err := service.Containers() if err != nil { logrus.Fatal(err) } if index < 1 || index > len(containers) { logrus.Fatalf("Invalid index %d", index) } output, err := containers[index-1].Port(fmt.Sprintf("%s/%s", c.Args()[1], protocol)) if err != nil { logrus.Fatal(err) } fmt.Println(output) }
func Upgrade(p *project.Project, from, to string, opts UpgradeOpts) error { fromService, err := p.CreateService(from) if err != nil { return err } toService, err := p.CreateService(to) if err != nil { return err } rFromService, ok := fromService.(*rancher.RancherService) if !ok { return fmt.Errorf("%s is not a Rancher service", from) } rToService, ok := toService.(*rancher.RancherService) if !ok { return fmt.Errorf("%s is not a Rancher service", to) } if err := rToService.Up(); err != nil { return err } source, err := rFromService.RancherService() if err != nil { return err } dest, err := rToService.RancherService() if err != nil { return err } upgradeOpts := &rancherClient.ServiceUpgrade{ UpdateLinks: opts.UpdateLinks, FinalScale: int64(opts.FinalScale), BatchSize: int64(opts.BatchSize), IntervalMillis: int64(opts.IntervalMillis), ToServiceId: dest.Id, } if upgradeOpts.FinalScale == -1 { upgradeOpts.FinalScale = source.Scale } client := rFromService.Client() logrus.Infof("Upgrading %s to %s, scale=%d", from, to, upgradeOpts.FinalScale) service, err := client.Service.ActionUpgrade(source, upgradeOpts) if err != nil { return err } if opts.Wait { return rFromService.Wait(service) } return nil }
// ProjectDelete deletes services. func ProjectDelete(p *project.Project, c *cli.Context) { stoppedContainers, err := p.ListStoppedContainers(c.Args()...) if err != nil { logrus.Fatal(err) } if len(stoppedContainers) == 0 { fmt.Println("No stopped containers") return } if !c.Bool("force") { fmt.Printf("Going to remove %v\nAre you sure? [yN]\n", strings.Join(stoppedContainers, ", ")) var answer string _, err := fmt.Scanln(&answer) if err != nil { logrus.Fatal(err) } if answer != "y" && answer != "Y" { return } } err = p.Delete(c.Args()...) if err != nil { logrus.Fatal(err) } }
func addServices(p *project.Project, enabled map[interface{}]interface{}, configs map[string]*composeConfig.ServiceConfigV1) map[interface{}]interface{} { serviceConfigsV2, _ := composeConfig.ConvertServices(configs) // Note: we ignore errors while loading services unchanged := true for name, serviceConfig := range serviceConfigsV2 { hash := composeConfig.GetServiceHash(name, serviceConfig) if enabled[name] == hash { continue } if err := p.AddConfig(name, serviceConfig); err != nil { log.Infof("Failed loading service %s", name) continue } if unchanged { enabled = util.MapCopy(enabled) unchanged = false } enabled[name] = hash } return enabled }
func ProjectLog(p *project.Project, c *cli.Context) { err := p.Log(c.Args()...) if err != nil { logrus.Fatal(err) } wait() }
func ProjectDelete(p *project.Project, c *cli.Context) { if !c.Bool("force") && len(c.Args()) == 0 { logrus.Fatal("Will not remove all services with out --force") } err := p.Delete(c.Args()...) if err != nil { logrus.Fatal(err) } }
// ProjectLog gets services logs. func ProjectLog(p *project.Project, c *cli.Context) { err := p.Log(c.Args()...) if err != nil { logrus.Fatal(err) } if c.Bool("follow") { wait() } }
func ProjectUp(p *project.Project, c *cli.Context) { err := p.Up(c.Args()...) if err != nil { logrus.Fatal(err) } if !c.Bool("d") { wait() } }
func ProjectCreate(p *project.Project, c *cli.Context) { if err := p.Create(c.Args()...); err != nil { logrus.Fatal(err) } // This is to fix circular links... What!? It works. if err := p.Create(c.Args()...); err != nil { logrus.Fatal(err) } }
func ProjectUp(p *project.Project, c *cli.Context) { if err := p.Create(c.Args()...); err != nil { logrus.Fatal(err) } if err := p.Up(c.Args()...); err != nil { logrus.Fatal(err) } if !c.Bool("d") { // wait forever <-make(chan interface{}) } }
func addServices(p *project.Project, cfg *config.CloudConfig, enabled map[string]string, configs map[string]*project.ServiceConfig) { // Note: we ignore errors while loading services for name, serviceConfig := range configs { hash := project.GetServiceHash(name, *serviceConfig) if enabled[name] == hash { continue } if err := p.AddConfig(name, serviceConfig); err != nil { log.Infof("Failed loading service %s", name) continue } enabled[name] = hash } }
func ProjectPs(p *project.Project, c *cli.Context) { allInfo := project.InfoSet{} for name := range p.Configs { service, err := p.CreateService(name) if err != nil { logrus.Fatal(err) } info, err := service.Info() if err != nil { logrus.Fatal(err) } allInfo = append(allInfo, info...) } os.Stdout.WriteString(allInfo.String()) }
// ProjectPs lists the containers. func ProjectPs(p *project.Project, c *cli.Context) { allInfo := project.InfoSet{} qFlag := c.Bool("q") for _, name := range p.Configs.Keys() { service, err := p.CreateService(name) if err != nil { logrus.Fatal(err) } info, err := service.Info(qFlag) if err != nil { logrus.Fatal(err) } allInfo = append(allInfo, info...) } os.Stdout.WriteString(allInfo.String(!qFlag)) }
// ProjectRun runs a given command within a service's container. func ProjectRun(p *project.Project, c *cli.Context) { if len(c.Args()) == 1 { logrus.Fatal("No service specified") } serviceName := c.Args()[0] commandParts := c.Args()[1:] if !p.Configs.Has(serviceName) { logrus.Fatalf("%s is not defined in the template", serviceName) } exitCode, err := p.Run(serviceName, commandParts) if err != nil { logrus.Fatal(err) } os.Exit(exitCode) }
func ProjectScale(p *project.Project, c *cli.Context) { // This code is a bit verbose but I wanted to parse everything up front order := make([]string, 0, 0) serviceScale := make(map[string]int) services := make(map[string]project.Service) for _, arg := range c.Args() { kv := strings.SplitN(arg, "=", 2) if len(kv) != 2 { logrus.Fatalf("Invalid scale parameter: %s", arg) } name := kv[0] count, err := strconv.Atoi(kv[1]) if err != nil { logrus.Fatalf("Invalid scale parameter: %v", err) } if _, ok := p.Configs[name]; !ok { logrus.Fatalf("% is not defined in the template", name) } service, err := p.CreateService(name) if err != nil { logrus.Fatalf("Failed to lookup service: %s: %v", service, err) } order = append(order, name) serviceScale[name] = count services[name] = service } for _, name := range order { scale := serviceScale[name] logrus.Infof("Setting scale %s=%d...", name, scale) err := services[name].Scale(scale) if err != nil { logrus.Fatalf("Failed to set the scale %s=%d: %v", name, scale, err) } } }
func upgradeInfo(up bool, p *project.Project, from, to string, opts UpgradeOpts) (*rancherClient.Service, *rancherClient.Service, *rancherClient.RancherClient, error) { fromService, err := p.CreateService(from) if err != nil { return nil, nil, nil, err } toService, err := p.CreateService(to) if err != nil { return nil, nil, nil, err } rFromService, ok := fromService.(*rancher.RancherService) if !ok { return nil, nil, nil, fmt.Errorf("%s is not a Rancher service", from) } rToService, ok := toService.(*rancher.RancherService) if !ok { return nil, nil, nil, fmt.Errorf("%s is not a Rancher service", to) } if up { if err := rToService.Up(); err != nil { return nil, nil, nil, err } } source, err := rFromService.RancherService() if err != nil { return nil, nil, nil, err } dest, err := rToService.RancherService() if err != nil { return nil, nil, nil, err } return source, dest, rFromService.Client(), nil }
func LoadService(p *project.Project, cfg *config.CloudConfig, useNetwork bool, service string) error { bytes, err := network.LoadServiceResource(service, useNetwork, cfg) if err != nil { return err } m := map[interface{}]interface{}{} if err = yaml.Unmarshal(bytes, &m); err != nil { return fmt.Errorf("Failed to parse YAML configuration for %s: %v", service, err) } m = adjustContainerNames(m) bytes, err = yaml.Marshal(m) if err != nil { return fmt.Errorf("Failed to marshal YAML configuration for %s: %v", service, err) } if err = p.Load(bytes); err != nil { return fmt.Errorf("Failed to load %s: %v", service, err) } return nil }
func getPid(service string, project *project.Project) (int, error) { s, err := project.CreateService(service) if err != nil { return 0, err } containers, err := s.Containers(context.Background()) if err != nil { return 0, err } if len(containers) == 0 { return 0, nil } client, err := composeClient.Create(composeClient.Options{ Host: config.DOCKER_SYSTEM_HOST, }) if err != nil { return 0, err } id, err := containers[0].ID() if err != nil { return 0, err } info, err := client.ContainerInspect(context.Background(), id) if err != nil || info.ID == "" { return 0, err } if info.State.Running { return info.State.Pid, nil } return 0, nil }
func getPid(service string, project *project.Project) (int, error) { s, err := project.CreateService(service) if err != nil { return 0, err } containers, err := s.Containers() if err != nil { return 0, err } if len(containers) == 0 { return 0, nil } client, err := docker.CreateClient(docker.ClientOpts{ Host: config.DOCKER_SYSTEM_HOST, }) if err != nil { return 0, err } id, err := containers[0].Id() if err != nil { return 0, err } info, err := client.InspectContainer(id) if err != nil || info == nil { return 0, err } if info.State.Running { return info.State.Pid, nil } return 0, nil }
func Upgrade(p *project.Project, from, to string, opts UpgradeOpts) error { fromService, err := p.CreateService(from) if err != nil { return err } toService, err := p.CreateService(to) if err != nil { return err } rFromService, ok := fromService.(*rancher.RancherService) if !ok { return fmt.Errorf("%s is not a Rancher service", from) } source, err := rFromService.RancherService() if err != nil { return err } if source == nil { return fmt.Errorf("Failed to find service %s", from) } if source.LaunchConfig.Labels["io.rancher.scheduler.global"] == "true" { return fmt.Errorf("Upgrade is not supported for global services") } rToService, ok := toService.(*rancher.RancherService) if !ok { return fmt.Errorf("%s is not a Rancher service", to) } if service, err := rToService.RancherService(); err != nil { return err } else if service == nil { if err := rToService.Create(); err != nil { return err } if err := rToService.Scale(0); err != nil { return err } } if err := rToService.Up(); err != nil { return err } dest, err := rToService.RancherService() if err != nil { return err } if dest == nil { return fmt.Errorf("Failed to find service %s", to) } if dest.LaunchConfig.Labels["io.rancher.scheduler.global"] == "true" { return fmt.Errorf("Upgrade is not supported for global services") } upgradeOpts := &rancherClient.ServiceUpgrade{ ToServiceStrategy: &rancherClient.ToServiceUpgradeStrategy{ UpdateLinks: opts.UpdateLinks, FinalScale: int64(opts.FinalScale), BatchSize: int64(opts.BatchSize), IntervalMillis: int64(opts.IntervalMillis), ToServiceId: dest.Id, }, } if upgradeOpts.ToServiceStrategy.FinalScale == -1 { upgradeOpts.ToServiceStrategy.FinalScale = source.Scale } client := rFromService.Client() if opts.Pull { if err := rToService.Pull(); err != nil { return err } } logrus.Infof("Upgrading %s to %s, scale=%d", from, to, upgradeOpts.ToServiceStrategy.FinalScale) service, err := client.Service.ActionUpgrade(source, upgradeOpts) if err != nil { return err } if opts.Wait || opts.CleanUp { if err := rFromService.Wait(service); err != nil { return err } } if opts.CleanUp { // Reload source to check scale source, err = rFromService.RancherService() if err != nil { return err } if source.Scale == 0 { if err := rFromService.Delete(); err != nil { return err } } else { logrus.Warnf("Not deleting service %s, scale is not 0 but %d", source.Name, source.Scale) } } return nil }
func ProjectCreate(p *project.Project, c *cli.Context) { err := p.Create(c.Args()...) if err != nil { logrus.Fatal(err) } }
func ProjectPull(p *project.Project, c *cli.Context) { err := p.Pull(c.Args()...) if err != nil { logrus.Fatal(err) } }
func ProjectRestart(p *project.Project, c *cli.Context) { err := p.Restart(c.Args()...) if err != nil { logrus.Fatal(err) } }