Framework/Models/SVT/PSCloudService.ps1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
#
# CloudService.ps1
#
Set-StrictMode -Version Latest 
class PSCloudService
{
    [PSObject] $CloudServiceName
    [PSObject] $CloudServiceRGName    
    [DeploymentSlot[]] $DeploymentSlots    
    [PSObject] $VirtualIps
    [PSObject] $UpgradeType
    [PSObject] $UpgradeDomainCount
    [Extension[]] $Extensions
    [string] $CloudServiceResourceType = "Microsoft.ClassicCompute/domainNames"
    [string] $CloudServiceAPIVersion = "2016-04-01"

    PSCloudService([string] $cloudServiceName, [string] $cloudServiceRGName)
    {
        $this.CloudServiceName = $cloudServiceName;
        $this.CloudServiceRGName = $cloudServiceRGName;
    }

    [void] LoadCloudConfiguration()
    {
        $cloudServiceSlots = Get-AzResource -ResourceGroupName $this.CloudServiceRGName `
                                -Name $this.CloudServiceName `
                                -ResourceType "$($this.CloudServiceResourceType)/slots" `
                                -ApiVersion $this.CloudServiceAPIVersion

        if(($cloudServiceSlots | Measure-Object).Count -gt 0)
        {
            $this.DeploymentSlots = @();            
            $cloudServiceSlots | ForEach-Object {
                $cloudSlot = $_;
                $DeploymentSlot    = [DeploymentSlot]::new();
                $DeploymentSlot.SlotName = $cloudSlot.Name;
                if(([Helpers]::CheckMember($cloudSlot,"Properties")) -and ([Helpers]::CheckMember($cloudSlot.Properties,"configuration")))
                {
                    $DeploymentSlot.CloudCSCFG = [xml]$cloudSlot.Properties.configuration

                    if($null -ne $DeploymentSlot.CloudCSCFG.ServiceConfiguration)                        
                    {
                        $DeploymentSlot.IsOSAutoUpdateTurnedOn = $false;
                        if($null -ne $DeploymentSlot.CloudCSCFG.ServiceConfiguration.Attributes["osVersion"] -and $DeploymentSlot.CloudCSCFG.ServiceConfiguration.Attributes["osVersion"].value -eq "*")
                        {
                            $DeploymentSlot.IsOSAutoUpdateTurnedOn = $true;
                        }                        
                    }
                }
                
                if(([Helpers]::CheckMember($cloudSlot,"Properties")) -and ([Helpers]::CheckMember($cloudSlot.Properties,"slotType")))
                {
                    $DeploymentSlot.SlotType = $cloudSlot.Properties.slotType
                }

                #get roles
                $cloudServiceRoles = Get-AzResource -ResourceGroupName $this.CloudServiceRGName `
                                        -Name "$($this.CloudServiceName)/$($DeploymentSlot.SlotName)" `
                                        -ResourceType "$($this.CloudServiceResourceType)/slots/roles" `
                                        -ApiVersion $this.CloudServiceAPIVersion
    
                if(($cloudServiceRoles | Measure-Object).Count -gt 0)
                {
                    $DeploymentSlot.Roles = @();
                    $cloudServiceRoles | ForEach-Object{
                        $cloudRole = $_;
                        $Role = [Role]::new();
                        $Role.RoleName = $cloudRole.Name
                        if([Helpers]::CheckMember($cloudRole,"Properties"))
                        {
                            $Role.OSVersion = $cloudRole.Properties.osVersion    
                            $cloudRoleProps = $cloudRole.Properties;
                            if([Helpers]::CheckMember($cloudRoleProps,"inputEndpoints") -and ($cloudRoleProps.inputEndpoints | Measure-Object).Count -gt 0)
                            {
                                $Role.InputEndpoints = @();                                
                                $cloudRole.Properties.inputEndpoints | ForEach-Object{
                                    $roleInputEP = $_
                                    $InputEndPoint = [InputEndpoint]::new();
                                    if([Helpers]::CheckMember($roleInputEP,"publicIpAddress"))
                                    {
                                        $InputEndPoint.PublicIPAddress = $roleInputEP.publicIpAddress;
                                    }
                                    $InputEndPoint.Protocol = $roleInputEP.protocol;
                                    $InputEndPoint.PrivatePort = $roleInputEP.privatePort;
                                    $InputEndPoint.PublicPort = $roleInputEP.publicPort;
                                    if([Helpers]::CheckMember($roleInputEP,"virtualIpName"))
                                    {
                                        $InputEndPoint.VirtualIPName = $roleInputEP.virtualIpName;
                                    }
                                    $Role.InputEndpoints += $InputEndPoint;
                                }
                            }                            
                        }
                        $Role.IsRemoteAccessEnabled = $false;
                        $Role.IsRemoteForwarderEnabled = $false;
                        if($null-ne $DeploymentSlot.CloudCSCFG `
                            -and $null -ne $DeploymentSlot.CloudCSCFG.ServiceConfiguration `
                            -and $null -ne $DeploymentSlot.CloudCSCFG.ServiceConfiguration.Role)
                        {
                            foreach($configRole in $DeploymentSlot.CloudCSCFG.ServiceConfiguration.Role)
                            {
                                if($configRole.name -eq $Role.RoleName)
                                {
                                    if([Helpers]::CheckMember($configRole,"ConfigurationSettings") -and $null -ne $configRole.ConfigurationSettings `
                                        -and [Helpers]::CheckMember($configRole.ConfigurationSettings,"Setting") `
                                        -and $null -ne $configRole.ConfigurationSettings.Setting)
                                        {
                                            foreach ($setting in $configRole.ConfigurationSettings.Setting)
                                            {
                                                if($setting.name -eq "Microsoft.WindowsAzure.Plugins.RemoteAccess.Enabled" -and $setting.value -eq "true")
                                                {
                                                    $Role.IsRemoteAccessEnabled = $true;
                                                }
                                                elseif($setting.name -eq "Microsoft.WindowsAzure.Plugins.RemoteForwarder.Enabled" -and $setting.value -eq "true")
                                                {
                                                    $Role.IsRemoteForwarderEnabled = $true;
                                                }
                                            }
                                        }
                                }
                            }
                        }
                        $DeploymentSlot.Roles += $Role;

                    }
                }        
                
                $this.DeploymentSlots += $DeploymentSlot;
            }
        }        
    }

    hidden [void] LoadCloudConfigurationFromClassicConfig([xml] $CloudServiceResponse)
    {                
        # Get the results from the API as XML
        
        if($null -ne $CloudServiceResponse.hostedservice)
        {        
            if([Helpers]::CheckMember($CloudServiceResponse.hostedservice, "Deployments")){
                if([Helpers]::CheckMember($CloudServiceResponse.hostedservice.Deployments , "Deployment")){
                foreach($svc in $CloudServiceResponse.hostedservice.Deployments.Deployment)
                {
                    $DeploymentSlot = $this.DeploymentSlots | Where-Object { $_.SlotName -eq $svc.DeploymentSlot}
                    
                    if($null -ne $svc.RoleInstanceList)
                    {
                        foreach($instance in $svc.RoleInstanceList.RoleInstance)
                        {
                            [RoleInstance] $roleInstance = [RoleInstance]::new()
                            $roleInstance.RoleName = $instance.RoleName
                            $roleInstance.InstanceName = $instance.InstanceName
                            $roleInstance.PowerState = $instance.PowerState
                            if([Helpers]::CheckMember($instance, "IpAddress"))
                            {
                                $roleInstance.IPAddress = $instance.IpAddress
                            }
                            
                            if([Helpers]::CheckMember($instance, "InstanceEndpoints") -and $null -ne $instance.InstanceEndpoints -and $null -ne $instance.InstanceEndpoints.InstanceEndpoint)
                            {
                                $roleInstance.InstanceEndpoints = [array]($instance.InstanceEndpoints.InstanceEndpoint | Select-Object Name, Vip, PublicPort, LocalPort, Protocol)
                            }

                            $Role = $DeploymentSlot.Roles | Where-Object { $_.RoleName -eq $roleInstance.RoleName}
                            if($null -eq $Role.RoleInstances)
                            {
                                $Role.RoleInstances = @()
                            }

                            if([Helpers]::CheckMember($svc, "RoleList"))
                            {
                                $roleFromClassicObj = $svc.RoleList.Role | Where-Object { $_.RoleName -eq $roleInstance.RoleName }
                            
                                if($null -ne $roleFromClassicObj)
                                {
                                    if([Helpers]::CheckMember($roleFromClassicObj, "RoleType"))
                                    {
                                        $Role.RoleType = $roleFromClassicObj.RoleType
                                    }
                                }
                            }
                            
                            $Role.RoleInstances += $roleInstance                
                            
                            if([Helpers]::CheckMember($svc, "VirtualIPs") -and [Helpers]::CheckMember($svc.VirtualIPs, "VirtualIP"))
                            {
                                $Role.VirtualIPs = [array]($svc.VirtualIPs.VirtualIP | Select-Object Address, IsDnsProgrammed)
                            }

                            if([Helpers]::CheckMember($svc, "UpgradeDomainCount"))
                            {
                                $Role.UpgradeDomainCount = $svc.UpgradeDomainCount
                            }

                            # Write-Host `nRole Extensions: -ForegroundColor DarkYellow
                            # Write-Host ------------------

                            $Role.Extensions = @()
                            if(([Helpers]::CheckMember($svc ,"ExtensionConfiguration")) -and ([Helpers]::CheckMember($svc.ExtensionConfiguration,"NamedRoles") ))
                            {
                                foreach($instanceRole in $svc.ExtensionConfiguration.NamedRoles.Role)
                                {
                                    if($instanceRole.RoleName -eq $instance.RoleName)
                                    {
                                        [Extension] $extension = [Extension]::new()
                                        $extension.RoleName = $instanceRole.RoleName            
                                        if($null -ne $instanceRole.Extensions.Extension)
                                        {
                                            $extension.ExtensionId =  ($instanceRole.Extensions.Extension | Select-Object Id ) 
                                        }
                                        $Role.Extensions += $extension
                                    }
                                }
                            }
                        }
                    }

                    
                  }
                }
            }
        }
    }    

}

class RoleInstance
{    
    [PSObject] $RoleName
    [PSObject] $InstanceName
    [PSObject] $PowerState
    [PSObject] $IPAddress
    [PSObject] $InstanceEndpoints
}

class Role
{
    [string] $RoleName
    [string] $OSVersion
    [string] $RoleType
    [InputEndpoint[]] $InputEndpoints
    [RoleInstance[]] $RoleInstances
    [bool] $IsRemoteForwarderEnabled
    [bool] $IsRemoteAccessEnabled
    [PSObject] $VirtualIPs
    [PSObject] $UpgradeDomainCount
    [Extension[]] $Extensions
}

class InputEndpoint
{
    [string] $PublicIPAddress
    [string] $PrivatePort
    [string] $PublicPort
    [string] $Protocol
    [string] $VirtualIPName
}

class Extension
{
    [PSObject] $RoleName
    [PSObject] $ExtensionId
}

class DeploymentSlot
{
    [string] $SlotName
    [PSObject] $CloudCSCFG 
    [Role[]] $Roles
    [bool] $IsOSAutoUpdateTurnedOn
    [string] $SlotType
}