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
}
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 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))
}
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 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 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 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
}