// addFrontEndRegistration adds registration code for frontends to the given units
func addFrontEndRegistration(t *jobs.Task, main *sdunits.Unit, ctx generatorContext) error {
if len(t.PublicFrontEnds) == 0 && len(t.PrivateFrontEnds) == 0 {
return nil
}
serviceName := t.ServiceName()
targetServiceName := serviceName
if t.Type == "proxy" {
targetServiceName = t.Target.EtcdServiceName()
}
httpKey := fmt.Sprintf("/pulcy/frontend/%s-%d", serviceName, ctx.ScalingGroup)
httpRecord := api.FrontendRecord{
Service: targetServiceName,
HttpCheckPath: t.HttpCheckPath,
HttpCheckMethod: t.HttpCheckMethod,
Sticky: t.Sticky,
Backup: t.Backup,
Mode: "", // Defaults to http
}
tcpKey := fmt.Sprintf("/pulcy/frontend/%s-%d-tcp", serviceName, ctx.ScalingGroup)
tcpRecord := api.FrontendRecord{
Service: targetServiceName,
HttpCheckPath: t.HttpCheckPath,
HttpCheckMethod: t.HttpCheckMethod,
Sticky: t.Sticky,
Backup: t.Backup,
Mode: "tcp",
}
instanceHttpKey := fmt.Sprintf("/pulcy/frontend/%s-%d-inst", serviceName, ctx.ScalingGroup)
instanceHttpRecord := api.FrontendRecord{
Service: fmt.Sprintf("%s-%d", targetServiceName, ctx.ScalingGroup),
HttpCheckPath: t.HttpCheckPath,
Sticky: t.Sticky,
Backup: t.Backup,
}
instanceTcpKey := fmt.Sprintf("/pulcy/frontend/%s-%d-inst-tcp", serviceName, ctx.ScalingGroup)
instanceTcpRecord := api.FrontendRecord{
Service: fmt.Sprintf("%s-%d", targetServiceName, ctx.ScalingGroup),
HttpCheckPath: t.HttpCheckPath,
Sticky: t.Sticky,
Backup: t.Backup,
Mode: "tcp",
}
var rwRules []api.RewriteRule
if t.Type == "proxy" && t.Rewrite != nil {
rwRules = append(rwRules, api.RewriteRule{
PathPrefix: t.Rewrite.PathPrefix,
RemovePathPrefix: t.Rewrite.RemovePathPrefix,
Domain: t.Rewrite.Domain,
})
}
for _, fr := range t.PublicFrontEnds {
record := &httpRecord
if fr.Mode == "tcp" {
record = &tcpRecord
}
selRecord := api.FrontendSelectorRecord{
Weight: fr.Weight,
Domain: fr.Domain,
PathPrefix: fr.PathPrefix,
SslCert: fr.SslCert,
ServicePort: fr.Port,
FrontendPort: fr.HostPort,
RewriteRules: rwRules,
}
if err := addUsers(t, &selRecord, fr.Users); err != nil {
return maskAny(err)
}
record.Selectors = append(record.Selectors, selRecord)
}
for _, fr := range t.PrivateFrontEnds {
record := &httpRecord
instanceRecord := &instanceHttpRecord
if fr.Mode == "tcp" {
record = &tcpRecord
instanceRecord = &instanceTcpRecord
}
selRecord := api.FrontendSelectorRecord{
Domain: t.PrivateDomainName(),
ServicePort: fr.Port,
FrontendPort: fr.HostPort,
Private: true,
RewriteRules: rwRules,
}
if err := addUsers(t, &selRecord, fr.Users); err != nil {
return maskAny(err)
}
record.Selectors = append(record.Selectors, selRecord)
if fr.RegisterInstance {
instanceSelRecord := selRecord
instanceSelRecord.Domain = t.InstanceSpecificPrivateDomainName(ctx.ScalingGroup)
instanceRecord.Selectors = append(instanceRecord.Selectors, instanceSelRecord)
}
}
if len(instanceHttpRecord.Selectors) > 0 {
if err := addFrontEndRegistrationRecord(t, main, instanceHttpKey, instanceHttpRecord, "FrontEndRegistration-i"); err != nil {
return maskAny(err)
}
}
if len(instanceTcpRecord.Selectors) > 0 {
if err := addFrontEndRegistrationRecord(t, main, instanceTcpKey, instanceTcpRecord, "FrontEndRegistration-i-tcp"); err != nil {
return maskAny(err)
}
}
if len(httpRecord.Selectors) > 0 {
if err := addFrontEndRegistrationRecord(t, main, httpKey, httpRecord, "FrontEndRegistration"); err != nil {
return maskAny(err)
}
}
if len(tcpRecord.Selectors) > 0 {
if err := addFrontEndRegistrationRecord(t, main, tcpKey, tcpRecord, "FrontEndRegistration-tcp"); err != nil {
return maskAny(err)
}
}
return nil
}
// createMainDockerCmdLine creates the `ExecStart` line for
// the main unit.
func (e *dockerEngine) createMainDockerCmdLine(t *jobs.Task, image string, env map[string]string, scalingGroup uint) (cmdline.Cmdline, error) {
serviceName := t.ServiceName()
cmd, err := e.createDockerCmd(env, t.Network)
if err != nil {
return cmd, maskAny(err)
}
cmd.Add(nil, "run", "--rm", fmt.Sprintf("--name %s", t.ContainerName(scalingGroup)))
if err := e.addDockerNetworkArgs(&cmd, env, t); err != nil {
return cmd, maskAny(err)
}
if len(t.Ports) > 0 {
for _, p := range t.Ports {
cmd.Add(env, fmt.Sprintf("-p %s", p))
}
} else {
cmd.Add(env, "-P")
}
for i, v := range t.Volumes {
if v.IsLocal() {
cmd.Add(env, fmt.Sprintf("-v %s", v))
} else if !v.IsLocal() {
cmd.Add(env, fmt.Sprintf("--volumes-from %s", createVolumeUnitContainerName(t, i, scalingGroup)))
}
}
for _, secret := range t.Secrets {
if ok, path := secret.TargetFile(); ok {
hostPath, err := secretFilePath(t, scalingGroup, secret)
if err != nil {
return cmdline.Cmdline{}, maskAny(err)
}
cmd.Add(env, fmt.Sprintf("-v %s:%s:ro", hostPath, path))
}
}
for _, name := range t.VolumesFrom {
other, err := t.Task(name)
if err != nil {
return cmdline.Cmdline{}, maskAny(err)
}
for i, v := range other.Volumes {
if !v.IsLocal() {
cmd.Add(env, fmt.Sprintf("--volumes-from %s", createVolumeUnitContainerName(other, i, scalingGroup)))
}
}
cmd.Add(env, fmt.Sprintf("--volumes-from %s", other.ContainerName(scalingGroup)))
}
envKeys := []string{}
for k := range t.Environment {
envKeys = append(envKeys, k)
}
sort.Strings(envKeys)
if e.options.EnvFile != "" {
cmd.Add(env, fmt.Sprintf("--env-file=%s", e.options.EnvFile))
}
for _, k := range envKeys {
cmd.Add(env, "-e "+strconv.Quote(fmt.Sprintf("%s=%s", k, t.Environment[k])))
}
if t.Secrets.AnyTargetEnviroment() {
cmd.Add(env, "--env-file="+secretEnvironmentPath(t, scalingGroup))
}
cmd.Add(env, fmt.Sprintf("-e SERVICE_NAME=%s", serviceName)) // Support registrator
for _, cap := range t.Capabilities {
cmd.Add(env, "--cap-add "+cap)
}
tcpLinkIndex := 0
for _, l := range t.Links {
targetName := l.Target.PrivateDomainName()
if l.Type.IsHTTP() {
cmd.Add(env, "--add-host")
cmd.Add(env, fmt.Sprintf("%s:${COREOS_PRIVATE_IPV4}", targetName))
} else {
linkContainerName := fmt.Sprintf("%s-pr%d", t.ContainerName(scalingGroup), tcpLinkIndex)
cmd.Add(env, fmt.Sprintf("--link %s:%s", linkContainerName, targetName))
tcpLinkIndex++
}
}
for _, arg := range t.LogDriver.CreateDockerLogArgs(e.options) {
cmd.Add(env, arg)
}
for _, arg := range t.DockerArgs {
cmd.Add(env, arg)
}
if t.User != "" {
cmd.Add(env, fmt.Sprintf("--user %s", t.User))
}
cmd.Add(nil, image)
if t.Type == "proxy" {
cmd.Add(nil, "sleep 36500d")
}
for _, arg := range t.Args {
cmd.Add(env, arg)
}
return cmd, nil
}
