func (s *SimpleStreamsToolsSuite) SetUpTest(c *gc.C) {
s.ToolsFixture.DefaultBaseURL = utils.MakeFileURL(s.publicToolsDir)
s.BaseSuite.SetUpTest(c)
s.ToolsFixture.SetUpTest(c)
s.origCurrentVersion = version.Current
s.reset(c, nil)
}
func (s *filestorageSuite) TestURL(c *gc.C) {
expectedpath, _ := s.createFile(c, "test-file")
_, file := filepath.Split(expectedpath)
url, err := s.reader.URL(file)
c.Assert(err, jc.ErrorIsNil)
c.Assert(url, gc.Equals, utils.MakeFileURL(expectedpath))
}
func (s *ValidateSuite) TestMajorVersionMatch(c *gc.C) {
s.makeLocalMetadata(c, "released", "1.11.2", "raring")
params := &ToolsMetadataLookupParams{
Major: 1,
Minor: -1,
MetadataLookupParams: simplestreams.MetadataLookupParams{
Region: "region-2",
Series: "raring",
Architectures: []string{"amd64"},
Endpoint: "some-auth-url",
Stream: "released",
Sources: []simplestreams.DataSource{
simplestreams.NewURLDataSource("test", s.toolsURL(), utils.VerifySSLHostnames)},
},
}
versions, resolveInfo, err := ValidateToolsMetadata(params)
c.Assert(err, jc.ErrorIsNil)
c.Assert(versions, gc.DeepEquals, []string{"1.11.2-raring-amd64"})
c.Check(resolveInfo, gc.DeepEquals, &simplestreams.ResolveInfo{
Source: "test",
Signed: false,
IndexURL: utils.MakeFileURL(path.Join(s.metadataDir, "tools/streams/v1/index2.json")),
MirrorURL: "",
})
}
func (suite *baseProviderSuite) setupFakeTools(c *gc.C) {
suite.PatchValue(&keys.JujuPublicKey, sstesting.SignedMetadataPublicKey)
storageDir := c.MkDir()
toolsDir := filepath.Join(storageDir, "tools")
suite.PatchValue(&envtools.DefaultBaseURL, utils.MakeFileURL(toolsDir))
suite.UploadFakeToolsToDirectory(c, storageDir, "released", "released")
}
func (s *syncToolsSuite) TestSyncToolsCommandDeprecatedDestination(c *gc.C) {
called := false
dir := c.MkDir()
syncTools = func(sctx *sync.SyncContext) error {
c.Assert(sctx.AllVersions, jc.IsFalse)
c.Assert(sctx.DryRun, jc.IsFalse)
c.Assert(sctx.Stream, gc.Equals, "released")
c.Assert(sctx.Source, gc.Equals, "")
c.Assert(sctx.TargetToolsUploader, gc.FitsTypeOf, sync.StorageToolsUploader{})
uploader := sctx.TargetToolsUploader.(sync.StorageToolsUploader)
url, err := uploader.Storage.URL("")
c.Assert(err, jc.ErrorIsNil)
c.Assert(url, gc.Equals, utils.MakeFileURL(dir))
called = true
return nil
}
// Register writer.
var tw loggo.TestWriter
c.Assert(loggo.RegisterWriter("deprecated-tester", &tw, loggo.DEBUG), gc.IsNil)
defer loggo.RemoveWriter("deprecated-tester")
// Add deprecated message to be checked.
messages := []jc.SimpleMessage{
{loggo.WARNING, "Use of the --destination flag is deprecated in 1.18. Please use --local-dir instead."},
}
// Run sync-tools command with --destination flag.
ctx, err := runSyncToolsCommand(c, "-m", "test-target", "--destination", dir, "--stream", "released")
c.Assert(err, jc.ErrorIsNil)
c.Assert(ctx, gc.NotNil)
c.Assert(called, jc.IsTrue)
// Check deprecated message was logged.
c.Check(tw.Log(), jc.LogMatches, messages)
}
func (s *SimpleStreamsToolsSuite) reset(c *gc.C, attrs map[string]interface{}) {
final := map[string]interface{}{
"agent-metadata-url": utils.MakeFileURL(s.customToolsDir),
"agent-stream": "proposed",
}
for k, v := range attrs {
final[k] = v
}
s.resetEnv(c, final)
}
func (t *Tests) SetUpTest(c *gc.C) {
storageDir := c.MkDir()
baseUrlPath := filepath.Join(storageDir, "tools")
t.DefaultBaseURL = utils.MakeFileURL(baseUrlPath)
t.ToolsFixture.SetUpTest(c)
stor, err := filestorage.NewFileStorageWriter(storageDir)
c.Assert(err, jc.ErrorIsNil)
t.UploadFakeTools(c, stor, "released", "released")
t.toolsStorage = stor
t.ControllerStore = jujuclienttesting.NewMemStore()
}
func (s *filestorageSuite) TestPathRelativeToHome(c *gc.C) {
homeDir := utils.Home()
tempDir, err := ioutil.TempDir(homeDir, "")
c.Assert(err, jc.ErrorIsNil)
defer os.RemoveAll(tempDir)
dirName := strings.Replace(tempDir, homeDir, "", -1)
reader, err := filestorage.NewFileStorageReader(filepath.Join(utils.Home(), dirName))
c.Assert(err, jc.ErrorIsNil)
url, err := reader.URL("")
c.Assert(err, jc.ErrorIsNil)
c.Assert(url, gc.Equals, utils.MakeFileURL(filepath.Join(homeDir, dirName)))
}
func (t *LiveTests) SetUpTest(c *gc.C) {
t.CleanupSuite.SetUpTest(c)
t.PatchValue(&jujuversion.Current, coretesting.FakeVersionNumber)
storageDir := c.MkDir()
baseUrlPath := filepath.Join(storageDir, "tools")
t.DefaultBaseURL = utils.MakeFileURL(baseUrlPath)
t.ToolsFixture.SetUpTest(c)
stor, err := filestorage.NewFileStorageWriter(storageDir)
c.Assert(err, jc.ErrorIsNil)
t.UploadFakeTools(c, stor, "released", "released")
t.toolsStorage = stor
t.CleanupSuite.PatchValue(&envtools.BundleTools, envtoolstesting.GetMockBundleTools(c))
}
func (s *ValidateSuite) assertMatch(c *gc.C, stream string) {
s.makeLocalMetadata(c, "1234", "region-2", "raring", "some-auth-url", stream)
metadataPath := filepath.Join(s.metadataDir, "images")
params := &simplestreams.MetadataLookupParams{
Region: "region-2",
Series: "raring",
Architectures: []string{"amd64"},
Endpoint: "some-auth-url",
Stream: stream,
Sources: []simplestreams.DataSource{
simplestreams.NewURLDataSource("test", utils.MakeFileURL(metadataPath), utils.VerifySSLHostnames, simplestreams.DEFAULT_CLOUD_DATA, false)},
}
imageIds, resolveInfo, err := imagemetadata.ValidateImageMetadata(params)
c.Assert(err, jc.ErrorIsNil)
c.Assert(imageIds, gc.DeepEquals, []string{"1234"})
c.Check(resolveInfo, gc.DeepEquals, &simplestreams.ResolveInfo{
Source: "test",
Signed: false,
IndexURL: utils.MakeFileURL(path.Join(metadataPath, "streams/v1/index.json")),
MirrorURL: "",
})
}
func (s *filestorageSuite) TestRelativePath(c *gc.C) {
dir := c.MkDir()
err := os.MkdirAll(filepath.Join(dir, "a", "b", "c"), os.ModePerm)
c.Assert(err, jc.ErrorIsNil)
cwd, err := os.Getwd()
c.Assert(err, jc.ErrorIsNil)
err = os.Chdir(filepath.Join(dir, "a", "b", "c"))
c.Assert(err, jc.ErrorIsNil)
defer os.Chdir(cwd)
reader, err := filestorage.NewFileStorageReader("../..")
c.Assert(err, jc.ErrorIsNil)
url, err := reader.URL("")
c.Assert(err, jc.ErrorIsNil)
c.Assert(url, gc.Equals, utils.MakeFileURL(dir)+"/a")
}
// UploadToDirectory uploads tools and metadata for the specified versions to dir.
func UploadToDirectory(c *gc.C, stream, dir string, versions ...version.Binary) map[version.Binary]string {
uploaded := map[version.Binary]string{}
if len(versions) == 0 {
return uploaded
}
for _, vers := range versions {
basePath := fmt.Sprintf("%s/tools-%s.tar.gz", stream, vers.String())
uploaded[vers] = utils.MakeFileURL(fmt.Sprintf("%s/%s", dir, basePath))
}
objects := generateMetadata(c, stream, versions...)
for _, object := range objects {
path := filepath.Join(dir, object.path)
dir := filepath.Dir(path)
if err := os.MkdirAll(dir, 0755); err != nil && !os.IsExist(err) {
c.Assert(err, jc.ErrorIsNil)
}
err := ioutil.WriteFile(path, object.data, 0644)
c.Assert(err, jc.ErrorIsNil)
}
return uploaded
}
// Fetch is defined in simplestreams.DataSource.
func (h *urlDataSource) Fetch(path string) (io.ReadCloser, string, error) {
dataURL := urlJoin(h.baseURL, path)
client := utils.GetHTTPClient(h.hostnameVerification)
// dataURL can be http:// or file://
// MakeFileURL will only modify the URL if it's a file URL
dataURL = utils.MakeFileURL(dataURL)
resp, err := client.Get(dataURL)
if err != nil {
logger.Tracef("Got error requesting %q: %v", dataURL, err)
return nil, dataURL, errors.NotFoundf("invalid URL %q", dataURL)
}
if resp.StatusCode == http.StatusNotFound {
return nil, dataURL, errors.NotFoundf("cannot find URL %q", dataURL)
}
if resp.StatusCode == http.StatusUnauthorized {
return nil, dataURL, errors.Unauthorizedf("unauthorised access to URL %q", dataURL)
}
if resp.StatusCode != http.StatusOK {
return nil, dataURL, fmt.Errorf("cannot access URL %q, %q", dataURL, resp.Status)
}
return resp.Body, dataURL, nil
}
func (s *syncToolsSuite) TestSyncToolsCommandTargetDirectory(c *gc.C) {
called := false
dir := c.MkDir()
syncTools = func(sctx *sync.SyncContext) error {
c.Assert(sctx.AllVersions, jc.IsFalse)
c.Assert(sctx.DryRun, jc.IsFalse)
c.Assert(sctx.Stream, gc.Equals, "proposed")
c.Assert(sctx.Source, gc.Equals, "")
c.Assert(sctx.TargetToolsUploader, gc.FitsTypeOf, sync.StorageToolsUploader{})
uploader := sctx.TargetToolsUploader.(sync.StorageToolsUploader)
c.Assert(uploader.WriteMirrors, gc.Equals, envtools.DoNotWriteMirrors)
url, err := uploader.Storage.URL("")
c.Assert(err, jc.ErrorIsNil)
c.Assert(url, gc.Equals, utils.MakeFileURL(dir))
called = true
return nil
}
ctx, err := runSyncToolsCommand(c, "-m", "test-target", "--local-dir", dir, "--stream", "proposed")
c.Assert(err, jc.ErrorIsNil)
c.Assert(ctx, gc.NotNil)
c.Assert(called, jc.IsTrue)
}
func (s *windowsFileSuite) TestMakeFileURL(c *gc.C) {
var makeFileURLTests = []struct {
in string
expected string
}{{
in: "file://C:\\foo\\baz",
expected: "file://\\\\localhost\\C$/foo/baz",
}, {
in: "C:\\foo\\baz",
expected: "file://\\\\localhost\\C$/foo/baz",
}, {
in: "http://foo/baz",
expected: "http://foo/baz",
}, {
in: "file://\\\\localhost\\C$/foo/baz",
expected: "file://\\\\localhost\\C$/foo/baz",
}}
for i, t := range makeFileURLTests {
c.Logf("Test %d", i)
c.Assert(utils.MakeFileURL(t.in), gc.Equals, t.expected)
}
}
func GetURL(source, basePath string) (string, error) {
// If source is a raw directory, we need to append the file:// prefix
// so it can be used as a URL.
defaultURL := source
u, err := url.Parse(source)
if err != nil {
return "", fmt.Errorf("invalid default %s URL %s: %v", basePath, defaultURL, err)
}
switch u.Scheme {
case "http", "https", "file", "test":
return source, nil
}
if filepath.IsAbs(defaultURL) {
defaultURL = utils.MakeFileURL(defaultURL)
if !strings.HasSuffix(defaultURL, "/"+basePath) {
defaultURL = fmt.Sprintf("%s/%s", defaultURL, basePath)
}
} else {
return "", fmt.Errorf("%s is not an absolute path", source)
}
return defaultURL, nil
}
func (s *ValidateSuite) toolsURL() string {
return utils.MakeFileURL(path.Join(s.metadataDir, "tools"))
}
// URL implements storage.StorageReader.URL.
func (f *fileStorageReader) URL(name string) (string, error) {
return utils.MakeFileURL(filepath.Join(f.path, name)), nil
}
// URL is defined in simplestreams.DataSource.
func (h *urlDataSource) URL(path string) (string, error) {
return utils.MakeFileURL(urlJoin(h.baseURL, path)), nil
}