1 // Copyright (C) The Arvados Authors. All rights reserved.
3 // SPDX-License-Identifier: AGPL-3.0
6 // How to manually run individual tests against the real cloud
8 // $ go test -v git.curoverse.com/arvados.git/lib/cloud -live-azure-cfg azconfig.yml -check.f=TestListInstances
10 // Example azconfig.yml:
12 // subscription_id: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
13 // key: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
15 // cloud_environment: AzurePublicCloud
16 // secret: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
17 // tenant_id: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
18 // resource_group: zzzzz
20 // subnet: zzzzz-subnet-private
21 // storage_account: example
22 // blob_container: vhds
23 // image: "https://example.blob.core.windows.net/system/Microsoft.Compute/Images/images/zzzzz-compute-osDisk.XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX.vhd"
24 // delete_dangling_resources_after: 20
25 // authorized_key: "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDLQS1ExT2+WjA0d/hntEAyAtgeN1W2ik2QX8c2zO6HjlPHWXL92r07W0WMuDib40Pcevpi1BXeBWXA9ZB5KKMJB+ukaAu22KklnQuUmNvk6ZXnPKSkGxuCYvPQb08WhHf3p1VxiKfP3iauedBDM4x9/bkJohlBBQiFXzNUcQ+a6rKiMzmJN2gbL8ncyUzc+XQ5q4JndTwTGtOlzDiGOc9O4z5Dd76wtAVJneOuuNpwfFRVHThpJM6VThpCZOnl8APaceWXKeuwOuCae3COZMz++xQfxOfZ9Z8aIwo+TlQhsRaNfZ4Vjrop6ej8dtfZtgUFKfbXEOYaHrGrWGotFDTD example@example"
40 "git.curoverse.com/arvados.git/sdk/go/arvados"
41 "git.curoverse.com/arvados.git/sdk/go/config"
42 "github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2018-06-01/compute"
43 "github.com/Azure/azure-sdk-for-go/services/network/mgmt/2018-06-01/network"
44 "github.com/Azure/azure-sdk-for-go/storage"
45 "github.com/Azure/go-autorest/autorest"
46 "github.com/Azure/go-autorest/autorest/azure"
47 "github.com/Azure/go-autorest/autorest/to"
48 "github.com/jmcvetta/randutil"
49 "github.com/sirupsen/logrus"
50 "golang.org/x/crypto/ssh"
51 check "gopkg.in/check.v1"
54 type AzureInstanceSetSuite struct{}
56 var _ = check.Suite(&AzureInstanceSetSuite{})
58 type VirtualMachinesClientStub struct{}
60 func (*VirtualMachinesClientStub) CreateOrUpdate(ctx context.Context,
61 resourceGroupName string,
63 parameters compute.VirtualMachine) (result compute.VirtualMachine, err error) {
64 parameters.ID = &VMName
65 parameters.Name = &VMName
66 return parameters, nil
69 func (*VirtualMachinesClientStub) Delete(ctx context.Context, resourceGroupName string, VMName string) (result *http.Response, err error) {
73 func (*VirtualMachinesClientStub) ListComplete(ctx context.Context, resourceGroupName string) (result compute.VirtualMachineListResultIterator, err error) {
74 return compute.VirtualMachineListResultIterator{}, nil
77 type InterfacesClientStub struct{}
79 func (*InterfacesClientStub) CreateOrUpdate(ctx context.Context,
80 resourceGroupName string,
82 parameters network.Interface) (result network.Interface, err error) {
83 parameters.ID = to.StringPtr(nicName)
84 (*parameters.IPConfigurations)[0].PrivateIPAddress = to.StringPtr("192.168.5.5")
85 return parameters, nil
88 func (*InterfacesClientStub) Delete(ctx context.Context, resourceGroupName string, VMName string) (result *http.Response, err error) {
92 func (*InterfacesClientStub) ListComplete(ctx context.Context, resourceGroupName string) (result network.InterfaceListResultIterator, err error) {
93 return network.InterfaceListResultIterator{}, nil
96 var live = flag.String("live-azure-cfg", "", "Test with real azure API, provide config file")
98 func GetInstanceSet() (InstanceSet, ImageID, arvados.Cluster, error) {
99 cluster := arvados.Cluster{
100 InstanceTypes: arvados.InstanceTypeMap(map[string]arvados.InstanceType{
101 "tiny": arvados.InstanceType{
103 ProviderType: "Standard_D1_v2",
106 Scratch: 10000000000,
112 cfg := make(map[string]interface{})
113 err := config.LoadFile(&cfg, *live)
115 return nil, ImageID(""), cluster, err
117 ap, err := NewAzureInstanceSet(cfg, "test123", logrus.StandardLogger())
118 return ap, ImageID(cfg["image"].(string)), cluster, err
120 ap := AzureInstanceSet{
121 azconfig: AzureInstanceSetConfig{
122 BlobContainer: "vhds",
124 dispatcherID: "test123",
125 namePrefix: "compute-test123-",
126 logger: logrus.StandardLogger(),
127 deleteNIC: make(chan string),
128 deleteBlob: make(chan storage.Blob),
130 ap.ctx, ap.stopFunc = context.WithCancel(context.Background())
131 ap.vmClient = &VirtualMachinesClientStub{}
132 ap.netClient = &InterfacesClientStub{}
133 return &ap, ImageID("blob"), cluster, nil
137 func (*AzureInstanceSetSuite) TestCreate(c *check.C) {
138 ap, img, cluster, err := GetInstanceSet()
140 c.Fatal("Error making provider", err)
143 f, err := os.Open("azconfig_sshkey.pub")
144 c.Assert(err, check.IsNil)
146 keybytes, err := ioutil.ReadAll(f)
147 c.Assert(err, check.IsNil)
149 pk, _, _, _, err := ssh.ParseAuthorizedKey(keybytes)
150 c.Assert(err, check.IsNil)
152 nodetoken, err := randutil.String(40, "abcdefghijklmnopqrstuvwxyz0123456789")
153 c.Assert(err, check.IsNil)
155 inst, err := ap.Create(cluster.InstanceTypes["tiny"],
156 img, map[string]string{
157 "node-token": nodetoken},
160 c.Assert(err, check.IsNil)
163 log.Printf("Result %v %v %v", inst.String(), inst.Address(), tg)
167 func (*AzureInstanceSetSuite) TestListInstances(c *check.C) {
168 ap, _, _, err := GetInstanceSet()
170 c.Fatal("Error making provider", err)
173 l, err := ap.Instances(nil)
175 c.Assert(err, check.IsNil)
177 for _, i := range l {
179 log.Printf("%v %v %v", i.String(), i.Address(), tg)
183 func (*AzureInstanceSetSuite) TestManageNics(c *check.C) {
184 ap, _, _, err := GetInstanceSet()
186 c.Fatal("Error making provider", err)
189 ap.(*AzureInstanceSet).ManageNics()
193 func (*AzureInstanceSetSuite) TestManageBlobs(c *check.C) {
194 ap, _, _, err := GetInstanceSet()
196 c.Fatal("Error making provider", err)
199 ap.(*AzureInstanceSet).ManageBlobs()
203 func (*AzureInstanceSetSuite) TestDestroyInstances(c *check.C) {
204 ap, _, _, err := GetInstanceSet()
206 c.Fatal("Error making provider", err)
209 l, err := ap.Instances(nil)
210 c.Assert(err, check.IsNil)
212 for _, i := range l {
213 c.Check(i.Destroy(), check.IsNil)
217 func (*AzureInstanceSetSuite) TestDeleteFake(c *check.C) {
218 ap, _, _, err := GetInstanceSet()
220 c.Fatal("Error making provider", err)
223 _, err = ap.(*AzureInstanceSet).netClient.Delete(context.Background(), "fakefakefake", "fakefakefake")
225 de, ok := err.(autorest.DetailedError)
227 rq := de.Original.(*azure.RequestError)
229 log.Printf("%v %q %q", rq.Response.StatusCode, rq.ServiceError.Code, rq.ServiceError.Message)
233 func (*AzureInstanceSetSuite) TestWrapError(c *check.C) {
234 retryError := autorest.DetailedError{
235 Original: &azure.RequestError{
236 DetailedError: autorest.DetailedError{
237 Response: &http.Response{
239 Header: map[string][]string{"Retry-After": []string{"123"}},
242 ServiceError: &azure.ServiceError{},
245 wrapped := WrapAzureError(retryError)
246 _, ok := wrapped.(RateLimitError)
247 c.Check(ok, check.Equals, true)
249 quotaError := autorest.DetailedError{
250 Original: &azure.RequestError{
251 DetailedError: autorest.DetailedError{
252 Response: &http.Response{
256 ServiceError: &azure.ServiceError{
257 Message: "No more quota",
261 wrapped = WrapAzureError(quotaError)
262 _, ok = wrapped.(QuotaError)
263 c.Check(ok, check.Equals, true)
266 func (*AzureInstanceSetSuite) TestSetTags(c *check.C) {
267 ap, _, _, err := GetInstanceSet()
269 c.Fatal("Error making provider", err)
271 l, err := ap.Instances(nil)
272 c.Assert(err, check.IsNil)
275 err = l[0].SetTags(map[string]string{"foo": "bar"})
277 c.Fatal("Error setting tags", err)
280 l, err = ap.Instances(nil)
281 c.Assert(err, check.IsNil)
285 log.Printf("tags are %v", tg)
289 func (*AzureInstanceSetSuite) TestSSH(c *check.C) {
290 ap, _, _, err := GetInstanceSet()
292 c.Fatal("Error making provider", err)
294 l, err := ap.Instances(nil)
295 c.Assert(err, check.IsNil)
299 sshclient, err := SetupSSHClient(c, l[0])
300 c.Assert(err, check.IsNil)
302 sess, err := sshclient.NewSession()
303 c.Assert(err, check.IsNil)
305 out, err := sess.Output("cat /home/crunch/node-token")
306 c.Assert(err, check.IsNil)
308 log.Printf("%v", string(out))
310 sshclient.Conn.Close()
314 func SetupSSHClient(c *check.C, inst Instance) (*ssh.Client, error) {
315 addr := inst.Address() + ":2222"
317 return nil, errors.New("instance has no address")
320 f, err := os.Open("azconfig_sshkey")
321 c.Assert(err, check.IsNil)
323 keybytes, err := ioutil.ReadAll(f)
324 c.Assert(err, check.IsNil)
326 priv, err := ssh.ParsePrivateKey(keybytes)
327 c.Assert(err, check.IsNil)
329 var receivedKey ssh.PublicKey
330 client, err := ssh.Dial("tcp", addr, &ssh.ClientConfig{
332 Auth: []ssh.AuthMethod{
333 ssh.PublicKeys(priv),
335 HostKeyCallback: func(hostname string, remote net.Addr, key ssh.PublicKey) error {
339 Timeout: time.Minute,
344 } else if receivedKey == nil {
345 return nil, errors.New("BUG: key was never provided to HostKeyCallback")
348 err = inst.VerifyHostKey(receivedKey, client)
349 c.Assert(err, check.IsNil)