diff --git a/config/config_test.go b/config/config_test.go index e4c322d..d858cfa 100644 --- a/config/config_test.go +++ b/config/config_test.go @@ -261,9 +261,6 @@ Address=10.209.171.177/19 if u.Name != "50-eth0.network" { t.Errorf("Unit has incorrect name %s", u.Name) } - if u.Type() != "network" { - t.Errorf("Unit has incorrect type '%s'", u.Type()) - } } if cfg.Coreos.OEM.ID != "rackspace" { diff --git a/config/unit.go b/config/unit.go index 1f56a1e..93ed3f1 100644 --- a/config/unit.go +++ b/config/unit.go @@ -16,11 +16,6 @@ package config -import ( - "path/filepath" - "strings" -) - type Unit struct { Name string `yaml:"name"` Mask bool `yaml:"mask"` @@ -34,17 +29,3 @@ type Unit struct { // until the correct behaviour for multiple drop-in units is determined. DropIn bool `yaml:"-"` } - -func (u *Unit) Type() string { - ext := filepath.Ext(u.Name) - return strings.TrimLeft(ext, ".") -} - -func (u *Unit) Group() string { - switch u.Type() { - case "network", "netdev", "link": - return "network" - default: - return "system" - } -} diff --git a/system/systemd_test.go b/system/systemd_test.go index 1a728f6..a728efd 100644 --- a/system/systemd_test.go +++ b/system/systemd_test.go @@ -46,10 +46,6 @@ Address=10.209.171.177/19 sd := &systemd{dir} dst := u.Destination(dir) - expectDst := path.Join(dir, "run", "systemd", "network", "50-eth0.network") - if dst != expectDst { - t.Fatalf("unit.Destination returned %s, expected %s", dst, expectDst) - } if err := sd.PlaceUnit(u); err != nil { t.Fatalf("PlaceUnit failed: %v", err) @@ -80,30 +76,6 @@ Address=10.209.171.177/19 } } -func TestUnitDestination(t *testing.T) { - dir := "/some/dir" - name := "foobar.service" - - u := Unit{config.Unit{ - Name: name, - DropIn: false, - }} - - dst := u.Destination(dir) - expectDst := path.Join(dir, "etc", "systemd", "system", "foobar.service") - if dst != expectDst { - t.Errorf("unit.Destination returned %s, expected %s", dst, expectDst) - } - - u.DropIn = true - - dst = u.Destination(dir) - expectDst = path.Join(dir, "etc", "systemd", "system", "foobar.service.d", cloudConfigDropIn) - if dst != expectDst { - t.Errorf("unit.Destination returned %s, expected %s", dst, expectDst) - } -} - func TestPlaceMountUnit(t *testing.T) { u := Unit{config.Unit{ Name: "media-state.mount", @@ -123,10 +95,6 @@ Where=/media/state sd := &systemd{dir} dst := u.Destination(dir) - expectDst := path.Join(dir, "etc", "systemd", "system", "media-state.mount") - if dst != expectDst { - t.Fatalf("unit.Destination returned %s, expected %s", dst, expectDst) - } if err := sd.PlaceUnit(u); err != nil { t.Fatalf("PlaceUnit failed: %v", err) diff --git a/system/unit.go b/system/unit.go index b48db7b..897a853 100644 --- a/system/unit.go +++ b/system/unit.go @@ -19,6 +19,8 @@ package system import ( "fmt" "path" + "path/filepath" + "strings" "github.com/coreos/coreos-cloudinit/config" ) @@ -36,11 +38,30 @@ type UnitManager interface { } // Unit is a top-level structure which embeds its underlying configuration, -// config.Unit, and provides the system-specific Destination(). +// config.Unit, and provides the system-specific Destination(), Type(), and +// Group(). type Unit struct { config.Unit } +// Type returns the extension of the unit (everything that follows the final +// period). +func (u Unit) Type() string { + ext := filepath.Ext(u.Name) + return strings.TrimLeft(ext, ".") +} + +// Group returns "network" or "system" depending on whether or not the unit is +// a network unit or otherwise. +func (u Unit) Group() string { + switch u.Type() { + case "network", "netdev", "link": + return "network" + default: + return "system" + } +} + // Destination builds the appropriate absolute file path for the Unit. The root // argument indicates the effective base directory of the system (similar to a // chroot). diff --git a/system/unit_test.go b/system/unit_test.go new file mode 100644 index 0000000..0303694 --- /dev/null +++ b/system/unit_test.go @@ -0,0 +1,100 @@ +/* + Copyright 2014 CoreOS, Inc. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +*/ + +package system + +import ( + "testing" + + "github.com/coreos/coreos-cloudinit/config" +) + +func TestType(t *testing.T) { + tests := []struct { + name string + + typ string + }{ + {}, + {"test.service", "service"}, + {"hello", ""}, + {"lots.of.dots", "dots"}, + } + + for _, tt := range tests { + u := Unit{config.Unit{ + Name: tt.name, + }} + if typ := u.Type(); tt.typ != typ { + t.Errorf("bad type (%+v): want %q, got %q", tt, tt.typ, typ) + } + } +} + +func TestGroup(t *testing.T) { + tests := []struct { + name string + + group string + }{ + {"test.service", "system"}, + {"test.link", "network"}, + {"test.network", "network"}, + {"test.netdev", "network"}, + {"test.conf", "system"}, + } + + for _, tt := range tests { + u := Unit{config.Unit{ + Name: tt.name, + }} + if group := u.Group(); tt.group != group { + t.Errorf("bad group (%+v): want %q, got %q", tt, tt.group, group) + } + } +} + +func TestDestination(t *testing.T) { + tests := []struct { + root string + name string + runtime bool + + destination string + }{ + { + root: "/some/dir", + name: "foobar.service", + destination: "/some/dir/etc/systemd/system/foobar.service", + }, + { + root: "/some/dir", + name: "foobar.service", + runtime: true, + destination: "/some/dir/run/systemd/system/foobar.service", + }, + } + + for _, tt := range tests { + u := Unit{config.Unit{ + Name: tt.name, + Runtime: tt.runtime, + }} + if d := u.Destination(tt.root); tt.destination != d { + t.Errorf("bad destination (%+v): want %q, got %q", tt, tt.destination, d) + } + } +}