Пример #1
0
 public Droplet(DigitalOcean.API.Models.Responses.Droplet apiDroplet)
 {
     DoUid      = apiDroplet.Id;
     Name       = apiDroplet.Name;
     PublicIpV4 = apiDroplet.Networks.V4.FirstOrDefault(g => g.Type == "public") == null
         ? null : apiDroplet.Networks.V4.FirstOrDefault(g => g.Type == "public").IpAddress;
     PrivateIpV4 = apiDroplet.Networks.V4.FirstOrDefault(g => g.Type != "public") == null
         ? null : apiDroplet.Networks.V4.FirstOrDefault(g => g.Type != "public").IpAddress;
     PublicIpV6 = apiDroplet.Networks.V6.FirstOrDefault(g => g.Type == "public") == null
         ? null : apiDroplet.Networks.V6.FirstOrDefault(g => g.Type == "public").IpAddress;
     CurrentImageName = apiDroplet.Image.Name;
     CurrentImageId   = apiDroplet.Image.Id;
     if (apiDroplet.Features != null)
     {
         MonitoringEnabled = apiDroplet.Features.Any(t => t == "monitoring");
         IpV6Enabled       = apiDroplet.Features.Any(t => t == "ipv6");
         BackupsEnabled    = apiDroplet.Features.Any(t => t == "backups");
     }
     Locked = apiDroplet.Locked;
     Status = apiDroplet.Status;
 }
        public async Task DropletRebuildSuccessfull()
        {
            // Arrange
            var userId      = 111;
            var dropletResp = new DigitalOcean.API.Models.Responses.Droplet()
            {
                Id   = 777,
                Size = new DigitalOcean.API.Models.Responses.Size()
                {
                    Regions = new List <string>()
                    {
                        "nyc3"
                    },
                    Memory       = 1,
                    PriceHourly  = 5,
                    PriceMonthly = 30,
                    Slug         = "khkhjkh",
                    Transfer     = 2.6,
                    Vcpus        = 6,
                    Disk         = 22
                },
                SizeSlug = "s-1vcpu-1gb",
                Name     = "TestDroplet",
                Networks = new DigitalOcean.API.Models.Responses.Network
                {
                    V4 = new List <DigitalOcean.API.Models.Responses.InterfaceV4>
                    {
                        new DigitalOcean.API.Models.Responses.InterfaceV4()
                        {
                            IpAddress = "testv4",
                            Type      = "public",
                        },
                        new DigitalOcean.API.Models.Responses.InterfaceV4()
                        {
                            IpAddress = "testv4private",
                            Type      = "private",
                        }
                    },
                    V6 = new List <DigitalOcean.API.Models.Responses.InterfaceV6>()
                    {
                        new DigitalOcean.API.Models.Responses.InterfaceV6()
                        {
                            IpAddress = "testv6",
                            Type      = "public"
                        }
                    }
                },
                Tags = new List <string>()
                {
                    "test", "Test2"
                },
                Image = new DigitalOcean.API.Models.Responses.Image
                {
                    Id   = 888,
                    Name = "MyTestImage"
                },
                Features = new List <string>()
                {
                    "ipv6", "backups", "monitoring"
                },
            };
            var imageResp = new DigitalOcean.API.Models.Responses.Image()
            {
                Id   = 888,
                Slug = "s-1vcpu-1gbimage",
                Name = "TestDroplet",
                Tags = new List <string>()
                {
                    "test", "Test2"
                },
                Type         = "test image type",
                Distribution = "test distribution",
                Public       = true,
                Regions      = new List <string>()
                {
                    "nyc3"
                },
                CreatedAt     = DateTime.Now,
                MinDiskSize   = 50,
                SizeGigabytes = 53,
                Description   = "test image description",
                Status        = "running",
                ErrorMessage  = null
            };

            var rebuildResp = new DigitalOcean.API.Models.Responses.Action()
            {
                Status = "completed"
            };
            var apiDropletResp = Task.FromResult(new List <DigitalOcean.API.Models.Responses.Droplet>()
            {
                dropletResp
            });
            var apiImageResp = Task.FromResult(new List <DigitalOcean.API.Models.Responses.Image>()
            {
                imageResp
            });

            var apiClient = new Mock <IApiClient>();

            apiClient.Setup(g => g.GetDroplet(It.IsAny <int>())).Returns(Task.FromResult(dropletResp));
            apiClient.Setup(g => g.GetDropletsList()).Returns(apiDropletResp);
            apiClient.Setup(g => g.RebuildDroplet(It.IsAny <long>(), It.IsAny <long>())).Returns(Task.FromResult(rebuildResp));
            apiClient.Setup(g => g.GetImagesList()).Returns(apiImageResp);
            var manager = new DigitalOceanManager(DbContext, apiClient.Object);

            // Act
            await manager.FetchDropletsAsync(userId);

            await manager.RebuildDropletAsync(userId, 777, 888);

            // Assert
            var createdDroplet = await DbContext.Droplets.Where(t => t.Id == 1).FirstOrDefaultAsync();

            var createdSize = await DbContext.Sizes.Where(t => t.Id == 1).FirstOrDefaultAsync();

            var createdTags = await DbContext.Tags.ToListAsync();

            var createdDropletTags = await DbContext.DropletTag.Where(t => t.DropletId == createdDroplet.Id).ToListAsync();

            var createdRegions = await DbContext.Regions.ToListAsync();

            var createdSizeRegions = await DbContext.SizeRegion.Where(t => t.SizeId == createdSize.Id).ToListAsync();

            // tags
            Assert.IsTrue(createdTags.Select(t => t.Name).Except(dropletResp.Tags).Count() == 0);
            foreach (var tag in createdTags)
            {
                CheckBaseCreateInfo(userId, tag);
                Assert.IsNotNull(tag.Name);
            }

            // regions
            Assert.IsTrue(createdRegions.Select(t => t.Name).Except(dropletResp.Size.Regions).Count() == 0);
            foreach (var reg in createdRegions)
            {
                CheckBaseCreateInfo(userId, reg);
                Assert.IsNotNull(reg.Name);
            }

            // size
            CheckBaseUpdateInfo(userId, createdSize, 2);
            Assert.AreEqual(createdSize.Memory, dropletResp.Size.Memory);
            Assert.AreEqual(createdSize.PriceHourly, dropletResp.Size.PriceHourly);
            Assert.AreEqual(createdSize.PriceMonthly, dropletResp.Size.PriceMonthly);
            Assert.AreEqual(createdSize.Slug, dropletResp.Size.Slug);
            Assert.AreEqual(createdSize.Transfer, dropletResp.Size.Transfer);
            Assert.AreEqual(createdSize.Vcpus, dropletResp.Size.Vcpus);
            Assert.AreEqual(createdSize.Disk, dropletResp.Size.Disk);

            // droplet
            CheckBaseUpdateInfo(userId, createdDroplet, 3);
            Assert.AreEqual(createdDroplet.DoUid, dropletResp.Id);
            Assert.AreEqual(createdDroplet.CustomerNo, 0);
            Assert.AreEqual(createdDroplet.PublicIpV4, dropletResp.Networks.V4[0].IpAddress);
            Assert.AreEqual(createdDroplet.PrivateIpV4, dropletResp.Networks.V4[1].IpAddress);
            Assert.AreEqual(createdDroplet.PublicIpV6, dropletResp.Networks.V6[0].IpAddress);
            Assert.AreEqual(createdDroplet.CurrentImageName, dropletResp.Image.Name);
            Assert.AreEqual(null, createdDroplet.RequestedImageName);
            Assert.AreEqual(createdDroplet.CurrentImageId, dropletResp.Image.Id);
            Assert.AreEqual(0, createdDroplet.RequestedImageId);
            Assert.IsNull(createdDroplet.UserData);
            Assert.AreEqual(createdDroplet.MonitoringEnabled, dropletResp.Features.Contains("monitoring"));
            Assert.AreEqual(createdDroplet.IpV6Enabled, dropletResp.Features.Contains("ipv6"));
            Assert.AreEqual(createdDroplet.BackupsEnabled, dropletResp.Features.Contains("backups"));
            Assert.AreEqual(createdDroplet.Sizeid, createdSize.Id);

            // TODO Add tests for DropletVersions

            // dropletTag
            Assert.AreEqual(createdDropletTags.Count, createdTags.Count);
            foreach (var dt in createdDropletTags)
            {
                CheckBaseUpdateInfo(userId, dt);

                Assert.AreEqual(createdDroplet.Id, dt.DropletId);
                Assert.IsTrue(createdTags.Select(t => t.Id).Contains(dt.TagId));
            }

            // regionsize
            Assert.AreEqual(createdSizeRegions.Count, createdRegions.Count);
            foreach (var sr in createdSizeRegions)
            {
                CheckBaseUpdateInfo(userId, sr);

                Assert.AreEqual(createdSize.Id, sr.SizeId);
                Assert.IsTrue(createdRegions.Select(t => t.Id).Contains(sr.RegionId));
            }
        }
Пример #3
0
        public async Task PowerDrop(int id, int option, DigitalOcean.API.Models.Responses.Droplet droplet)
        {
            Android.Support.V7.App.AlertDialog.Builder alert = new Android.Support.V7.App.AlertDialog.Builder(this);
            Button   reboot     = FindViewById <Button>(Resource.Id.Reboot);
            Button   PowerCycle = FindViewById <Button>(Resource.Id.PowerCycle);
            Switch   switcher   = FindViewById <Switch>(Resource.Id.switch1);
            TextView statustext = FindViewById <TextView>(Resource.Id.status);

            switcher.Enabled   = false;
            reboot.Enabled     = false;
            PowerCycle.Enabled = false;

            //DigitalOcean.API.Models.Responses.Action action;
            //DigitalOcean.API.Models.Responses.Action actionget;

            alert.SetNegativeButton("Cancel", (senderAlert, args) =>
            {
                switcher.Checked = true;
                Toast.MakeText(this, "Cancelled!", ToastLength.Short).Show();
                switcher.Enabled   = true;
                reboot.Enabled     = true;
                PowerCycle.Enabled = true;
            });

            Dialog dialog = alert.Create();

            alert.SetCancelable(false);
            switch (option)
            {
            case 0:
                alert.SetTitle("Confirm Poweroff");
                alert.SetMessage("Are you sure you want to force a shutdown?\nThis may cause data loss and corruption.\n Do you want to continue?");
                alert.SetPositiveButton("OK", async(senderAlert, args) =>
                {
                    statustext.Text = "Shutting down";
                    statustext.SetTextColor(Color.ParseColor("#FF8C00"));
                    var action    = await client.DropletActions.PowerOff(droplet.Id);
                    var actionget = await client.Actions.Get(action.Id);
                    Toast.MakeText(this, action.Status, ToastLength.Short).Show();
                    while (actionget.Status != "completed")
                    {
                        actionget = await client.Actions.Get(action.Id);
                        Toast.MakeText(this, actionget.Status, ToastLength.Short).Show();
                    }
                    Toast.MakeText(this, action.Status, ToastLength.Short).Show();
                    await UpdateInfo(id);
                    DisableSwitch();
                });
                dialog = alert.Create();
                dialog.Show();
                break;

            case 1:
                statustext.Text = "Powering On";
                statustext.SetTextColor(Color.ParseColor("#FF8C00"));
                var _action = await client.DropletActions.PowerOn(droplet.Id);

                var _actionget = await client.Actions.Get(_action.Id);

                while (_actionget.Status != "completed")
                {
                    _actionget = await client.Actions.Get(_action.Id);
                }
                await UpdateInfo(id);

                DisableSwitch();
                break;

            case 2:
                alert.SetTitle("Confirm Reboot");
                alert.SetMessage("Are you sure you want to Reboot?\nThis may cause data loss and corruption, We reccomend trying to reboot from commandline.\n Do you want to continue?");
                alert.SetPositiveButton("OK", async(senderAlert, args) =>
                {
                    statustext.Text = "Rebooting";
                    statustext.SetTextColor(Color.ParseColor("#FF8C00"));
                    var action    = await client.DropletActions.Reboot(droplet.Id);
                    var actionget = await client.Actions.Get(action.Id);
                    Toast.MakeText(this, action.Status, ToastLength.Short).Show();
                    while (actionget.Status != "completed")
                    {
                        actionget = await client.Actions.Get(action.Id);
                        Toast.MakeText(this, actionget.Status, ToastLength.Short).Show();
                    }
                    Toast.MakeText(this, action.Status, ToastLength.Short).Show();
                    await UpdateInfo(id);
                    DisableSwitch();
                });
                dialog = alert.Create();
                dialog.Show();
                break;

            case 3:
                alert.SetTitle("Confirm PowerCycle");
                alert.SetMessage("Are you sure you want to Powercycle?\nThis may cause data loss and corruption, We reccomend trying to reboot from commandline fist.\n Do you want to continue?");
                alert.SetPositiveButton("OK", async(senderAlert, args) =>
                {
                    statustext.Text = "Cycling";
                    statustext.SetTextColor(Color.ParseColor("#FF8C00"));
                    var action    = await client.DropletActions.PowerCycle(droplet.Id);
                    var actionget = await client.Actions.Get(action.Id);
                    Toast.MakeText(this, action.Status, ToastLength.Short).Show();
                    while (actionget.Status != "completed")
                    {
                        actionget = await client.Actions.Get(action.Id);
                        Toast.MakeText(this, action.Status, ToastLength.Short).Show();
                    }
                    Toast.MakeText(this, action.Status, ToastLength.Short).Show();
                    await UpdateInfo(id);
                    DisableSwitch();
                });
                dialog = alert.Create();
                dialog.Show();
                break;
            }
            return;
        }
        public async Task Droplet_RemovedFromSyncSuccessfully()
        {
            // Arrange
            var userId = 111;

            #region synced first droplet
            var firstDropletResponse = new DigitalOcean.API.Models.Responses.Droplet()
            {
                Id   = 777,
                Size = new DigitalOcean.API.Models.Responses.Size()
                {
                    Regions = new List <string>()
                    {
                        "nyc3"
                    },
                    Memory       = 1,
                    PriceHourly  = 5,
                    PriceMonthly = 30,
                    Slug         = "khkhjkh",
                    Transfer     = 2.6,
                    Vcpus        = 6,
                    Disk         = 22
                },
                SizeSlug = "s-1vcpu-1gb",
                Name     = "TestDroplet",
                Networks = new DigitalOcean.API.Models.Responses.Network
                {
                    V4 = new List <DigitalOcean.API.Models.Responses.InterfaceV4>
                    {
                        new DigitalOcean.API.Models.Responses.InterfaceV4()
                        {
                            IpAddress = "testv4",
                            Type      = "public",
                        },
                        new DigitalOcean.API.Models.Responses.InterfaceV4()
                        {
                            IpAddress = "testv4private",
                            Type      = "private",
                        }
                    },
                    V6 = new List <DigitalOcean.API.Models.Responses.InterfaceV6>()
                    {
                        new DigitalOcean.API.Models.Responses.InterfaceV6()
                        {
                            IpAddress = "testv6",
                            Type      = "public"
                        }
                    }
                },
                Tags = new List <string>()
                {
                    "test", "Test2"
                },
                Image = new DigitalOcean.API.Models.Responses.Image
                {
                    Id   = 888,
                    Name = "MyTestImage"
                },
                Features = new List <string>()
                {
                    "ipv6", "backups", "monitoring"
                },
            };

            var apiResp = Task.FromResult(new List <DigitalOcean.API.Models.Responses.Droplet>()
            {
                firstDropletResponse
            });

            var apiClient = new Mock <IApiClient>();
            apiClient.Setup(g => g.GetDropletsList()).Returns(apiResp);
            var manager = new DigitalOceanManager(DbContext, apiClient.Object);
            await manager.FetchDropletsAsync(userId);

            #endregion


            var apiResp2 = Task.FromResult(new List <DigitalOcean.API.Models.Responses.Droplet>()
            {
            });
            apiClient.Setup(g => g.GetDropletsList()).Returns(apiResp2);

            // Act
            await manager.FetchDropletsAsync(userId);


            // Assert
            var createdDroplet     = (await DbContext.Droplets.AsNoTracking().ToListAsync()).Last();
            var createdSize        = (await DbContext.Sizes.AsNoTracking().ToListAsync()).Last();
            var createdDropletTags = await DbContext.DropletTag.AsNoTracking().Where(t => t.DropletId == createdDroplet.Id).ToListAsync();

            var createdSizeRegions = await DbContext.SizeRegion.AsNoTracking().Where(t => t.SizeId == createdSize.Id).ToListAsync();

            var createdTags = (await DbContext.Tags.AsNoTracking().ToListAsync())
                              .Where(t => createdDropletTags.Select(t => t.TagId)
                                     .Contains(t.Id))
                              .ToList();
            var createdRegions = (await DbContext.Regions.AsNoTracking().ToListAsync())
                                 .Where(t => createdSizeRegions.Select(t => t.RegionId)
                                        .Contains(t.Id))
                                 .ToList();

            // tags
            Assert.IsTrue(createdTags.Select(t => t.Name).Except(firstDropletResponse.Tags).Count() == 0);
            foreach (var tag in createdTags)
            {
                CheckBaseCreateInfo(userId, tag);
                Assert.IsNotNull(tag.Name);
            }

            // regions
            Assert.IsTrue(createdRegions.Select(t => t.Name).Except(firstDropletResponse.Size.Regions).Count() == 0);
            foreach (var reg in createdRegions)
            {
                CheckBaseCreateInfo(userId, reg);
                Assert.IsNotNull(reg.Name);
            }

            // size
            CheckBaseRemoveInfo(userId, createdSize);
            Assert.AreEqual(createdSize.Memory, firstDropletResponse.Size.Memory);
            Assert.AreEqual(createdSize.PriceHourly, firstDropletResponse.Size.PriceHourly);
            Assert.AreEqual(createdSize.PriceMonthly, firstDropletResponse.Size.PriceMonthly);
            Assert.AreEqual(createdSize.Slug, firstDropletResponse.Size.Slug);
            Assert.AreEqual(createdSize.Transfer, firstDropletResponse.Size.Transfer);
            Assert.AreEqual(createdSize.Vcpus, firstDropletResponse.Size.Vcpus);
            Assert.AreEqual(createdSize.Disk, firstDropletResponse.Size.Disk);

            // droplet
            CheckBaseRemoveInfo(userId, createdDroplet);
            Assert.AreEqual(createdDroplet.DoUid, firstDropletResponse.Id);
            Assert.AreEqual(createdDroplet.CustomerNo, 0);
            Assert.AreEqual(createdDroplet.PublicIpV4, firstDropletResponse.Networks.V4[0].IpAddress);
            Assert.AreEqual(createdDroplet.PrivateIpV4, firstDropletResponse.Networks.V4[1].IpAddress);
            Assert.AreEqual(createdDroplet.PublicIpV6, firstDropletResponse.Networks.V6[0].IpAddress);
            Assert.AreEqual(createdDroplet.CurrentImageName, firstDropletResponse.Image.Name);
            Assert.IsNull(createdDroplet.RequestedImageName);
            Assert.AreEqual(createdDroplet.CurrentImageId, firstDropletResponse.Image.Id);
            Assert.AreEqual(createdDroplet.RequestedImageId, 0);
            Assert.IsNull(createdDroplet.UserData);
            Assert.AreEqual(createdDroplet.MonitoringEnabled, firstDropletResponse.Features.Contains("monitoring"));
            Assert.AreEqual(createdDroplet.IpV6Enabled, firstDropletResponse.Features.Contains("ipv6"));
            Assert.AreEqual(createdDroplet.BackupsEnabled, firstDropletResponse.Features.Contains("backups"));
            Assert.AreEqual(createdDroplet.Sizeid, createdSize.Id);

            // dropletTag
            Assert.AreEqual(createdDropletTags.Count, createdTags.Count);
            foreach (var dt in createdDropletTags)
            {
                CheckBaseRemoveInfo(userId, dt);

                Assert.AreEqual(createdDroplet.Id, dt.DropletId);
                Assert.IsTrue(createdTags.Select(t => t.Id).Contains(dt.TagId));
            }

            // regionsize
            Assert.AreEqual(createdSizeRegions.Count, createdRegions.Count);
            foreach (var sr in createdSizeRegions)
            {
                CheckBaseCreateInfo(userId, sr);

                Assert.AreEqual(createdSize.Id, sr.SizeId);
                Assert.IsTrue(createdRegions.Select(t => t.Id).Contains(sr.RegionId));
            }
        }