func NewAd() *Ad {
return &Ad{
Mutex: new(sync.Mutex),
Title: namesgenerator.GetRandomName(0),
Path: namesgenerator.GetRandomName(0),
Impression: 0,
ClickedUsers: []*User{},
}
}
func Run(c *cli.Context) {
timeout := time.After(duration)
a := make(chan announcement)
defer timeTrack(time.Now(), "main", a)
d := make(chan int)
phils := []philosopher{}
forks := []fork{}
for i := PHILOS; i > 0; i-- {
names = append(names, namesgenerator.GetRandomName(0))
}
log.Println(names)
watcher(a)
// Initialize
for _, name := range names {
phils = append(phils, philosopher{name: name, announce: a, dying: d})
forks = append(forks, fork{toRight: make(chan int, 2), toLeft: make(chan int, 2)})
}
for i := range phils {
dude := &phils[i]
dude.leftIn, dude.leftOut = forks[i].toLeft, forks[i].toRight
if i == 0 {
dude.rightIn, dude.rightOut = forks[len(forks)-1].toRight, forks[len(forks)-1].toLeft
} else {
dude.rightIn, dude.rightOut = forks[i-1].toRight, forks[i-1].toLeft
}
}
// Launch the dudes
for i := range phils {
go phils[i].Live()
}
//Put forks on the table
for i, f := range forks {
go func(i int, f fork) {
if i%2 == 0 {
f.toLeft <- 1
} else {
f.toRight <- 1
}
}(i, f)
}
Wait:
for i := 0; i < PHILOS; {
select {
case _ = <-d:
i++
case _ = <-timeout:
a <- announcement{from: "Main", message: fmt.Sprintf("%v dudes died during the simulation, over the total of %v.", i, PHILOS)}
break Wait
}
}
summarize()
return
}
func keyGenerator(key *ConnKey) error {
for i := 0; i < 10; i++ {
key.Name = namesgenerator.GetRandomName(i)
if _, exsit := daemon.session[*key]; exsit {
continue
}
return nil
}
return errors.New("key generator fail")
}
func (s *DockerSuite) startContainerWithConfig(c *check.C, image string, config d.ContainerConfig) string {
if config.Name == "" {
config.Name = namesgenerator.GetRandomName(10)
}
container := s.project.StartWithConfig(c, image, config)
// FIXME(vdemeester) this is ugly (it's because of the / in front of the name in docker..)
return strings.SplitAfter(container.Name, "/")[1]
}
func (s *DockerSuite) startContainerWithConfig(c *check.C, config docker.CreateContainerOptions) string {
if config.Name == "" {
config.Name = namesgenerator.GetRandomName(10)
}
if config.Config.Labels == nil {
config.Config.Labels = map[string]string{}
}
config.Config.Labels[TestLabel] = "true"
container, err := s.client.CreateContainer(config)
c.Assert(err, checker.IsNil, check.Commentf("Error creating a container using config %v", config))
err = s.client.StartContainer(container.ID, &docker.HostConfig{})
c.Assert(err, checker.IsNil, check.Commentf("Error starting container %v", container))
return container.Name
}
func imageToName(image string) string {
name := image
fields := strings.Split(image, "/")
if len(fields) > 1 {
name = fields[len(fields)-1]
}
fields = strings.Split(name, ":")
if len(fields) < 2 {
name = name + "-" + utils.RandStr(10, "number")
} else {
name = fields[0] + "-" + fields[1] + "-" + utils.RandStr(10, "number")
}
validContainerNameChars := `[a-zA-Z0-9][a-zA-Z0-9_.-]`
validContainerNamePattern := regexp.MustCompile(`^/?` + validContainerNameChars + `+$`)
if !validContainerNamePattern.MatchString(name) {
name = namesgenerator.GetRandomName(0)
}
return name
}
func (daemon *Daemon) generateNewName(id string) (string, error) {
var name string
for i := 0; i < 6; i++ {
name = namesgenerator.GetRandomName(i)
if name[0] != '/' {
name = "/" + name
}
if _, err := daemon.containerGraph.Set(name, id); err != nil {
if !graphdb.IsNonUniqueNameError(err) {
return "", err
}
continue
}
return name, nil
}
name = "/" + stringid.TruncateID(id)
if _, err := daemon.containerGraph.Set(name, id); err != nil {
return "", err
}
return name, nil
}
func (daemon *Daemon) generateNewName(id string) (string, error) {
var name string
for i := 0; i < 6; i++ {
name = namesgenerator.GetRandomName(i)
if name[0] != '/' {
name = "/" + name
}
if err := daemon.nameIndex.Reserve(name, id); err != nil {
if err == registrar.ErrNameReserved {
continue
}
return "", err
}
return name, nil
}
name = "/" + stringid.TruncateID(id)
if err := daemon.nameIndex.Reserve(name, id); err != nil {
return "", err
}
return name, nil
}
// ServiceSpecToGRPC converts a ServiceSpec to a grpc ServiceSpec.
func ServiceSpecToGRPC(s types.ServiceSpec) (swarmapi.ServiceSpec, error) {
name := s.Name
if name == "" {
name = namesgenerator.GetRandomName(0)
}
serviceNetworks := make([]*swarmapi.NetworkAttachmentConfig, 0, len(s.Networks))
for _, n := range s.Networks {
serviceNetworks = append(serviceNetworks, &swarmapi.NetworkAttachmentConfig{Target: n.Target, Aliases: n.Aliases})
}
taskNetworks := make([]*swarmapi.NetworkAttachmentConfig, 0, len(s.TaskTemplate.Networks))
for _, n := range s.TaskTemplate.Networks {
taskNetworks = append(taskNetworks, &swarmapi.NetworkAttachmentConfig{Target: n.Target, Aliases: n.Aliases})
}
spec := swarmapi.ServiceSpec{
Annotations: swarmapi.Annotations{
Name: name,
Labels: s.Labels,
},
Task: swarmapi.TaskSpec{
Resources: resourcesToGRPC(s.TaskTemplate.Resources),
LogDriver: driverToGRPC(s.TaskTemplate.LogDriver),
Networks: taskNetworks,
ForceUpdate: s.TaskTemplate.ForceUpdate,
},
Networks: serviceNetworks,
}
containerSpec, err := containerToGRPC(s.TaskTemplate.ContainerSpec)
if err != nil {
return swarmapi.ServiceSpec{}, err
}
spec.Task.Runtime = &swarmapi.TaskSpec_Container{Container: containerSpec}
restartPolicy, err := restartPolicyToGRPC(s.TaskTemplate.RestartPolicy)
if err != nil {
return swarmapi.ServiceSpec{}, err
}
spec.Task.Restart = restartPolicy
if s.TaskTemplate.Placement != nil {
spec.Task.Placement = &swarmapi.Placement{
Constraints: s.TaskTemplate.Placement.Constraints,
}
}
if s.UpdateConfig != nil {
var failureAction swarmapi.UpdateConfig_FailureAction
switch s.UpdateConfig.FailureAction {
case types.UpdateFailureActionPause, "":
failureAction = swarmapi.UpdateConfig_PAUSE
case types.UpdateFailureActionContinue:
failureAction = swarmapi.UpdateConfig_CONTINUE
default:
return swarmapi.ServiceSpec{}, fmt.Errorf("unrecongized update failure action %s", s.UpdateConfig.FailureAction)
}
spec.Update = &swarmapi.UpdateConfig{
Parallelism: s.UpdateConfig.Parallelism,
Delay: *ptypes.DurationProto(s.UpdateConfig.Delay),
FailureAction: failureAction,
MaxFailureRatio: s.UpdateConfig.MaxFailureRatio,
}
if s.UpdateConfig.Monitor != 0 {
spec.Update.Monitor = ptypes.DurationProto(s.UpdateConfig.Monitor)
}
}
if s.EndpointSpec != nil {
if s.EndpointSpec.Mode != "" &&
s.EndpointSpec.Mode != types.ResolutionModeVIP &&
s.EndpointSpec.Mode != types.ResolutionModeDNSRR {
return swarmapi.ServiceSpec{}, fmt.Errorf("invalid resolution mode: %q", s.EndpointSpec.Mode)
}
spec.Endpoint = &swarmapi.EndpointSpec{}
spec.Endpoint.Mode = swarmapi.EndpointSpec_ResolutionMode(swarmapi.EndpointSpec_ResolutionMode_value[strings.ToUpper(string(s.EndpointSpec.Mode))])
for _, portConfig := range s.EndpointSpec.Ports {
spec.Endpoint.Ports = append(spec.Endpoint.Ports, &swarmapi.PortConfig{
Name: portConfig.Name,
Protocol: swarmapi.PortConfig_Protocol(swarmapi.PortConfig_Protocol_value[strings.ToUpper(string(portConfig.Protocol))]),
PublishMode: swarmapi.PortConfig_PublishMode(swarmapi.PortConfig_PublishMode_value[strings.ToUpper(string(portConfig.PublishMode))]),
TargetPort: portConfig.TargetPort,
PublishedPort: portConfig.PublishedPort,
})
}
}
// Mode
if s.Mode.Global != nil && s.Mode.Replicated != nil {
return swarmapi.ServiceSpec{}, fmt.Errorf("cannot specify both replicated mode and global mode")
}
if s.Mode.Global != nil {
spec.Mode = &swarmapi.ServiceSpec_Global{
Global: &swarmapi.GlobalService{},
}
} else if s.Mode.Replicated != nil && s.Mode.Replicated.Replicas != nil {
spec.Mode = &swarmapi.ServiceSpec_Replicated{
Replicated: &swarmapi.ReplicatedService{Replicas: *s.Mode.Replicated.Replicas},
}
} else {
spec.Mode = &swarmapi.ServiceSpec_Replicated{
Replicated: &swarmapi.ReplicatedService{Replicas: 1},
}
}
return spec, nil
}
// CreateServer creates a server using API based on typical server fields
func CreateServer(api *ScalewayAPI, c *ConfigCreateServer) (string, error) {
if c.CommercialType == "" {
c.CommercialType = os.Getenv("SCW_COMMERCIAL_TYPE")
if c.CommercialType == "" {
c.CommercialType = "C1"
}
}
if c.Name == "" {
c.Name = strings.Replace(namesgenerator.GetRandomName(0), "_", "-", -1)
}
var server ScalewayServerDefinition
server.CommercialType = c.CommercialType
server.Volumes = make(map[string]string)
server.DynamicIPRequired = &c.DynamicIPRequired
if c.IP != "" {
if anonuuid.IsUUID(c.IP) == nil {
server.PublicIP = c.IP
} else {
ips, err := api.GetIPS()
if err != nil {
return "", err
}
for _, ip := range ips.IPS {
if ip.Address == c.IP {
server.PublicIP = ip.ID
break
}
}
if server.PublicIP == "" {
return "", fmt.Errorf("IP address %v not found", c.IP)
}
}
}
server.Tags = []string{}
if c.Env != "" {
server.Tags = strings.Split(c.Env, " ")
}
if c.AdditionalVolumes != "" {
volumes := strings.Split(c.AdditionalVolumes, " ")
for i := range volumes {
volumeID, err := CreateVolumeFromHumanSize(api, volumes[i])
if err != nil {
return "", err
}
volumeIDx := fmt.Sprintf("%d", i+1)
server.Volumes[volumeIDx] = *volumeID
}
}
// FIXME build images only on ARM ?
imageIdentifier := &ScalewayImageIdentifier{
Arch: "arm",
Region: "fr-1",
}
server.Name = c.Name
inheritingVolume := false
_, err := humanize.ParseBytes(c.ImageName)
if err == nil {
// Create a new root volume
volumeID, err := CreateVolumeFromHumanSize(api, c.ImageName)
if err != nil {
return "", err
}
server.Volumes["0"] = *volumeID
} else {
// Use an existing image
// FIXME: handle snapshots
inheritingVolume = true
imageIdentifier, err = api.GetImageID(c.ImageName)
if err != nil {
return "", err
}
if imageIdentifier.Identifier != "" {
server.Image = &imageIdentifier.Identifier
} else {
snapshotID, err := api.GetSnapshotID(c.ImageName)
if err != nil {
return "", err
}
snapshot, err := api.GetSnapshot(snapshotID)
if err != nil {
return "", err
}
if snapshot.BaseVolume.Identifier == "" {
return "", fmt.Errorf("snapshot %v does not have base volume", snapshot.Name)
}
server.Volumes["0"] = snapshot.BaseVolume.Identifier
}
}
if c.Bootscript != "" {
bootscript, err := api.GetBootscriptID(c.Bootscript, imageIdentifier.Arch)
if err != nil {
return "", err
}
server.Bootscript = &bootscript
}
serverID, err := api.PostServer(server)
if err != nil {
return "", err
}
// For inherited volumes, we prefix the name with server hostname
if inheritingVolume {
createdServer, err := api.GetServer(serverID)
if err != nil {
return "", err
}
currentVolume := createdServer.Volumes["0"]
var volumePayload ScalewayVolumePutDefinition
newName := fmt.Sprintf("%s-%s", createdServer.Hostname, currentVolume.Name)
volumePayload.Name = &newName
volumePayload.CreationDate = ¤tVolume.CreationDate
volumePayload.Organization = ¤tVolume.Organization
volumePayload.Server.Identifier = ¤tVolume.Server.Identifier
volumePayload.Server.Name = ¤tVolume.Server.Name
volumePayload.Identifier = ¤tVolume.Identifier
volumePayload.Size = ¤tVolume.Size
volumePayload.ModificationDate = ¤tVolume.ModificationDate
volumePayload.ExportURI = ¤tVolume.ExportURI
volumePayload.VolumeType = ¤tVolume.VolumeType
err = api.PutVolume(currentVolume.Identifier, volumePayload)
if err != nil {
return "", err
}
}
return serverID, nil
}
. "github.com/popcorp/doenv/lib"
"time"
)
var CreateCommand = cli.Command{
Name: "create",
Aliases: []string{"c", "init", "setup"},
Usage: "Create a droplet (Initial setup)",
ArgsUsage: "<droplet name> [image] [region] [size]",
Action: func(c *cli.Context) {
var DropletName string
var Image string
var Region string
var Size string
if len(c.Args()) < 1 {
DropletName = namesgenerator.GetRandomName(1)
} else {
DropletName = c.Args().Get(0)
}
if len(c.Args()) < 2 {
Image = "debian-8-x64"
} else {
Image = c.Args().Get(1)
}
if len(c.Args()) < 3 {
Size = "512mb"
} else {
Size = c.Args().Get(2)
}
if len(c.Args()) < 4 {
Region = "nyc2"
// CreateServer creates a server using API based on typical server fields
func CreateServer(api *ScalewayAPI, imageName string, name string, bootscript string, env string, additionalVolumes string) (string, error) {
if name == "" {
name = strings.Replace(namesgenerator.GetRandomName(0), "_", "-", -1)
}
var server ScalewayServerDefinition
server.Volumes = make(map[string]string)
server.Tags = []string{}
if env != "" {
server.Tags = strings.Split(env, " ")
}
if additionalVolumes != "" {
volumes := strings.Split(additionalVolumes, " ")
for i := range volumes {
volumeID, err := CreateVolumeFromHumanSize(api, volumes[i])
if err != nil {
return "", err
}
volumeIDx := fmt.Sprintf("%d", i+1)
server.Volumes[volumeIDx] = *volumeID
}
}
server.Name = name
if bootscript != "" {
bootscript := api.GetBootscriptID(bootscript)
server.Bootscript = &bootscript
}
inheritingVolume := false
_, err := humanize.ParseBytes(imageName)
if err == nil {
// Create a new root volume
volumeID, err := CreateVolumeFromHumanSize(api, imageName)
if err != nil {
return "", err
}
server.Volumes["0"] = *volumeID
} else {
// Use an existing image
// FIXME: handle snapshots
inheritingVolume = true
image := api.GetImageID(imageName, false)
if image != "" {
server.Image = &image
} else {
snapshotID := api.GetSnapshotID(imageName)
snapshot, err := api.GetSnapshot(snapshotID)
if err != nil {
return "", err
}
if snapshot.BaseVolume.Identifier == "" {
return "", fmt.Errorf("snapshot %v does not have base volume", snapshot.Name)
}
server.Volumes["0"] = snapshot.BaseVolume.Identifier
}
}
serverID, err := api.PostServer(server)
if err != nil {
return "", nil
}
// For inherited volumes, we prefix the name with server hostname
if inheritingVolume {
createdServer, err := api.GetServer(serverID)
if err != nil {
return "", err
}
currentVolume := createdServer.Volumes["0"]
var volumePayload ScalewayVolumePutDefinition
newName := fmt.Sprintf("%s-%s", createdServer.Hostname, currentVolume.Name)
volumePayload.Name = &newName
volumePayload.CreationDate = ¤tVolume.CreationDate
volumePayload.Organization = ¤tVolume.Organization
volumePayload.Server.Identifier = ¤tVolume.Server.Identifier
volumePayload.Server.Name = ¤tVolume.Server.Name
volumePayload.Identifier = ¤tVolume.Identifier
volumePayload.Size = ¤tVolume.Size
volumePayload.ModificationDate = ¤tVolume.ModificationDate
volumePayload.ExportURI = ¤tVolume.ExportURI
volumePayload.VolumeType = ¤tVolume.VolumeType
err = api.PutVolume(currentVolume.Identifier, volumePayload)
if err != nil {
return "", err
}
}
return serverID, nil
}
func (ad *Advertiser) NewSlot() *Slot {
s := NewSlot(fmt.Sprintf("%d-%s", ad.Id, namesgenerator.GetRandomName(0)))
s.Advertiser = ad
ad.Slots = append(ad.Slots, s)
return s
}
// CreateServer creates a server using API based on typical server fields
func CreateServer(api *ScalewayAPI, c *ConfigCreateServer) (string, error) {
commercialType := os.Getenv("SCW_COMMERCIAL_TYPE")
if commercialType == "" {
commercialType = c.CommercialType
}
if len(commercialType) < 2 {
return "", errors.New("Invalid commercial type")
}
if c.Name == "" {
c.Name = strings.Replace(namesgenerator.GetRandomName(0), "_", "-", -1)
}
var server ScalewayServerDefinition
server.CommercialType = commercialType
server.Volumes = make(map[string]string)
server.DynamicIPRequired = &c.DynamicIPRequired
server.EnableIPV6 = c.EnableIPV6
if commercialType == "" {
return "", errors.New("You need to specify a commercial-type")
}
if c.IP != "" {
if anonuuid.IsUUID(c.IP) == nil {
server.PublicIP = c.IP
} else {
ips, err := api.GetIPS()
if err != nil {
return "", err
}
for _, ip := range ips.IPS {
if ip.Address == c.IP {
server.PublicIP = ip.ID
break
}
}
if server.PublicIP == "" {
return "", fmt.Errorf("IP address %v not found", c.IP)
}
}
}
server.Tags = []string{}
if c.Env != "" {
server.Tags = strings.Split(c.Env, " ")
}
switch c.CommercialType {
case "VC1M":
if c.AdditionalVolumes == "" {
c.AdditionalVolumes = "50G"
log.Debugf("This server needs a least 50G")
}
case "VC1L":
if c.AdditionalVolumes == "" {
c.AdditionalVolumes = "150G"
log.Debugf("This server needs a least 150G")
}
}
if c.AdditionalVolumes != "" {
volumes := strings.Split(c.AdditionalVolumes, " ")
for i := range volumes {
volumeID, err := CreateVolumeFromHumanSize(api, volumes[i])
if err != nil {
return "", err
}
volumeIDx := fmt.Sprintf("%d", i+1)
server.Volumes[volumeIDx] = *volumeID
}
}
arch := os.Getenv("SCW_TARGET_ARCH")
if arch == "" {
server.CommercialType = strings.ToUpper(server.CommercialType)
switch server.CommercialType[:2] {
case "C1":
arch = "arm"
case "C2", "VC":
arch = "x86_64"
default:
return "", fmt.Errorf("%s wrong commercial type", server.CommercialType)
}
}
region := os.Getenv("SCW_TARGET_REGION")
if region == "" {
region = "fr-1"
}
imageIdentifier := &ScalewayImageIdentifier{
Arch: arch,
Region: region,
}
server.Name = c.Name
inheritingVolume := false
_, err := humanize.ParseBytes(c.ImageName)
if err == nil {
// Create a new root volume
volumeID, errCreateVol := CreateVolumeFromHumanSize(api, c.ImageName)
if errCreateVol != nil {
return "", errCreateVol
}
server.Volumes["0"] = *volumeID
} else {
// Use an existing image
inheritingVolume = true
if anonuuid.IsUUID(c.ImageName) == nil {
server.Image = &c.ImageName
} else {
imageIdentifier, err = api.GetImageID(c.ImageName, arch)
if err != nil {
return "", err
}
if imageIdentifier.Identifier != "" {
server.Image = &imageIdentifier.Identifier
} else {
snapshotID, errGetSnapID := api.GetSnapshotID(c.ImageName)
if errGetSnapID != nil {
return "", errGetSnapID
}
snapshot, errGetSnap := api.GetSnapshot(snapshotID)
if errGetSnap != nil {
return "", errGetSnap
}
if snapshot.BaseVolume.Identifier == "" {
return "", fmt.Errorf("snapshot %v does not have base volume", snapshot.Name)
}
server.Volumes["0"] = snapshot.BaseVolume.Identifier
}
}
}
if c.Bootscript != "" {
bootscript := ""
if anonuuid.IsUUID(c.Bootscript) == nil {
bootscript = c.Bootscript
} else {
var errGetBootScript error
bootscript, errGetBootScript = api.GetBootscriptID(c.Bootscript, imageIdentifier.Arch)
if errGetBootScript != nil {
return "", errGetBootScript
}
}
server.Bootscript = &bootscript
}
serverID, err := api.PostServer(server)
if err != nil {
return "", err
}
// For inherited volumes, we prefix the name with server hostname
if inheritingVolume {
createdServer, err := api.GetServer(serverID)
if err != nil {
return "", err
}
currentVolume := createdServer.Volumes["0"]
size := uint64(currentVolume.Size.(float64))
var volumePayload ScalewayVolumePutDefinition
newName := fmt.Sprintf("%s-%s", createdServer.Hostname, currentVolume.Name)
volumePayload.Name = &newName
volumePayload.CreationDate = ¤tVolume.CreationDate
volumePayload.Organization = ¤tVolume.Organization
volumePayload.Server.Identifier = ¤tVolume.Server.Identifier
volumePayload.Server.Name = ¤tVolume.Server.Name
volumePayload.Identifier = ¤tVolume.Identifier
volumePayload.Size = &size
volumePayload.ModificationDate = ¤tVolume.ModificationDate
volumePayload.ExportURI = ¤tVolume.ExportURI
volumePayload.VolumeType = ¤tVolume.VolumeType
err = api.PutVolume(currentVolume.Identifier, volumePayload)
if err != nil {
return "", err
}
}
return serverID, nil
}
// validateCreateConfig() checks the parameters for ContainerCreate().
// It may "fix up" the config param passed into ConntainerCreate() if needed.
func validateCreateConfig(config *types.ContainerCreateConfig) error {
defer trace.End(trace.Begin("Container.validateCreateConfig"))
// process cpucount here
var cpuCount int64 = DefaultCPUs
// support windows client
if config.HostConfig.CPUCount > 0 {
cpuCount = config.HostConfig.CPUCount
} else {
// we hijack --cpuset-cpus in the non-windows case
if config.HostConfig.CpusetCpus != "" {
cpus := strings.Split(config.HostConfig.CpusetCpus, ",")
if c, err := strconv.Atoi(cpus[0]); err == nil {
cpuCount = int64(c)
} else {
return fmt.Errorf("Error parsing CPU count: %s", err)
}
}
}
config.HostConfig.CPUCount = cpuCount
// fix-up cpu/memory settings here
if cpuCount < MinCPUs {
config.HostConfig.CPUCount = MinCPUs
}
log.Infof("Container CPU count: %d", config.HostConfig.CPUCount)
// convert from bytes to MiB for vsphere
memoryMB := config.HostConfig.Memory / units.MiB
if memoryMB == 0 {
memoryMB = MemoryDefaultMB
} else if memoryMB < MemoryMinMB {
memoryMB = MemoryMinMB
}
// check that memory is aligned
if remainder := memoryMB % MemoryAlignMB; remainder != 0 {
log.Warnf("Default container VM memory must be %d aligned for hotadd, rounding up.", MemoryAlignMB)
memoryMB += MemoryAlignMB - remainder
}
config.HostConfig.Memory = memoryMB
log.Infof("Container memory: %d MB", config.HostConfig.Memory)
if config.NetworkingConfig == nil {
config.NetworkingConfig = &dnetwork.NetworkingConfig{}
}
if config.HostConfig == nil || config.Config == nil {
return BadRequestError("invalid config")
}
// validate port bindings
if config.HostConfig != nil {
var ips []string
if addrs, err := externalIPv4Addrs(); err != nil {
log.Warnf("could not get address for external interface: %s", err)
} else {
ips = make([]string, len(addrs))
for i := range addrs {
ips[i] = addrs[i].IP.String()
}
}
for _, pbs := range config.HostConfig.PortBindings {
for _, pb := range pbs {
if pb.HostIP != "" && pb.HostIP != "0.0.0.0" {
// check if specified host ip equals any of the addresses on the "client" interface
found := false
for _, i := range ips {
if i == pb.HostIP {
found = true
break
}
}
if !found {
return InternalServerError("host IP for port bindings is only supported for 0.0.0.0 and the external interface IP address")
}
}
start, end, _ := nat.ParsePortRangeToInt(pb.HostPort)
if start != end {
return InternalServerError("host port ranges are not supported for port bindings")
}
}
}
}
// TODO(jzt): users other than root are not currently supported
// We should check for USER in config.Config.Env once we support Dockerfiles.
if config.Config.User != "" && config.Config.User != "root" {
return InternalServerError("Failed to create container - users other than root are not currently supported")
}
// https://github.com/vmware/vic/issues/1378
if len(config.Config.Entrypoint) == 0 && len(config.Config.Cmd) == 0 {
return derr.NewRequestNotFoundError(fmt.Errorf("No command specified"))
}
// Was a name provided - if not create a friendly name
if config.Name == "" {
//TODO: Assume we could have a name collison here : need to
// provide validation / retry CDG June 9th 2016
config.Name = namesgenerator.GetRandomName(0)
}
return nil
}
// getRandomName generates a random, human-readable name to ease identification
// of different test resources.
func getRandomName() string {
// Remove characters that aren't allowed in hostnames for machines allocated
// by Terraform.
return strings.Replace(namesgenerator.GetRandomName(0), "_", "", -1)
}
func main() {
fmt.Println(namesgenerator.GetRandomName(0))
}
// ServiceSpecToGRPC converts a ServiceSpec to a grpc ServiceSpec.
func ServiceSpecToGRPC(s types.ServiceSpec) (swarmapi.ServiceSpec, error) {
name := s.Name
if name == "" {
name = namesgenerator.GetRandomName(0)
}
networks := make([]*swarmapi.ServiceSpec_NetworkAttachmentConfig, 0, len(s.Networks))
for _, n := range s.Networks {
networks = append(networks, &swarmapi.ServiceSpec_NetworkAttachmentConfig{Target: n.Target, Aliases: n.Aliases})
}
spec := swarmapi.ServiceSpec{
Annotations: swarmapi.Annotations{
Name: name,
Labels: s.Labels,
},
Task: swarmapi.TaskSpec{
Resources: resourcesToGRPC(s.TaskTemplate.Resources),
LogDriver: driverToGRPC(s.TaskTemplate.LogDriver),
},
Networks: networks,
}
containerSpec, err := containerToGRPC(s.TaskTemplate.ContainerSpec)
if err != nil {
return swarmapi.ServiceSpec{}, err
}
spec.Task.Runtime = &swarmapi.TaskSpec_Container{Container: containerSpec}
restartPolicy, err := restartPolicyToGRPC(s.TaskTemplate.RestartPolicy)
if err != nil {
return swarmapi.ServiceSpec{}, err
}
spec.Task.Restart = restartPolicy
if s.TaskTemplate.Placement != nil {
spec.Task.Placement = &swarmapi.Placement{
Constraints: s.TaskTemplate.Placement.Constraints,
}
}
if s.UpdateConfig != nil {
spec.Update = &swarmapi.UpdateConfig{
Parallelism: s.UpdateConfig.Parallelism,
Delay: *ptypes.DurationProto(s.UpdateConfig.Delay),
}
}
if s.EndpointSpec != nil {
if s.EndpointSpec.Mode != "" &&
s.EndpointSpec.Mode != types.ResolutionModeVIP &&
s.EndpointSpec.Mode != types.ResolutionModeDNSRR {
return swarmapi.ServiceSpec{}, fmt.Errorf("invalid resolution mode: %q", s.EndpointSpec.Mode)
}
spec.Endpoint = &swarmapi.EndpointSpec{}
spec.Endpoint.Mode = swarmapi.EndpointSpec_ResolutionMode(swarmapi.EndpointSpec_ResolutionMode_value[strings.ToUpper(string(s.EndpointSpec.Mode))])
for _, portConfig := range s.EndpointSpec.Ports {
spec.Endpoint.Ports = append(spec.Endpoint.Ports, &swarmapi.PortConfig{
Name: portConfig.Name,
Protocol: swarmapi.PortConfig_Protocol(swarmapi.PortConfig_Protocol_value[strings.ToUpper(string(portConfig.Protocol))]),
TargetPort: portConfig.TargetPort,
PublishedPort: portConfig.PublishedPort,
})
}
}
//Mode
if s.Mode.Global != nil {
spec.Mode = &swarmapi.ServiceSpec_Global{
Global: &swarmapi.GlobalService{},
}
} else if s.Mode.Replicated != nil && s.Mode.Replicated.Replicas != nil {
spec.Mode = &swarmapi.ServiceSpec_Replicated{
Replicated: &swarmapi.ReplicatedService{Replicas: *s.Mode.Replicated.Replicas},
}
} else {
spec.Mode = &swarmapi.ServiceSpec_Replicated{
Replicated: &swarmapi.ReplicatedService{Replicas: 1},
}
}
return spec, nil
}
