knife-azure 3.0.0 → 4.0.0

data/lib/azure/service_management/connection.rb

@@ -1,102 +0,0 @@
-#
-# Author:: Barry Davis (barryd@jetstreamsoftware.com)
-# Copyright:: Copyright (c) Chef Software Inc.
-# License:: Apache License, Version 2.0
-#
-# 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.
-#
-
-require_relative "image"
-require_relative "role"
-require_relative "deploy"
-require_relative "host"
-require_relative "loadbalancer"
-require_relative "vnet"
-require_relative "utility"
-require_relative "ag"
-require_relative "storageaccount"
-require_relative "certificate"
-require_relative "disk"
-
-module Azure
-  class ServiceManagement
-    class Connection
-      include AzureUtility
-      attr_accessor :hosts, :rest, :images, :deploys, :roles,
-        :disks, :storageaccounts, :certificates, :ags, :vnets, :lbs
-      def initialize(rest)
-        @images = Images.new(self)
-        @roles = Roles.new(self)
-        @deploys = Deploys.new(self)
-        @hosts = Hosts.new(self)
-        @rest = rest
-        @lbs = Loadbalancer.new(self)
-        @vnets = Vnets.new(self)
-        @ags = AGs.new(self)
-        @storageaccounts = StorageAccounts.new(self)
-        @certificates = Certificates.new(self)
-        @disks = Disks.new(self)
-      end
-
-      def query_azure(service_name,
-        verb = "get",
-        body = "",
-        params = "",
-        wait = true,
-        services = true,
-        content_type = nil)
-        Chef::Log.info "calling " + verb + " " + service_name + (wait ? " synchronously" : " asynchronously")
-        Chef::Log.debug body unless body == ""
-        response = @rest.query_azure(service_name, verb, body, params, services, content_type)
-        if response.code.to_i == 200
-          ret_val = Nokogiri::XML response.body
-        elsif !wait && response.code.to_i == 202
-          Chef::Log.debug "Request accepted in asynchronous mode"
-          ret_val = Nokogiri::XML response.body
-        elsif response.code.to_i >= 201 && response.code.to_i <= 299
-          ret_val = wait_for_completion
-        else
-          if response.body
-            ret_val = Nokogiri::XML response.body
-            Chef::Log.debug ret_val.to_xml
-            error_code, error_message = error_from_response_xml(ret_val)
-            Chef::Log.debug error_code + " : " + error_message if error_code.length > 0
-          else
-            Chef::Log.warn "http error: " + response.code
-          end
-        end
-        ret_val
-      end
-
-      def wait_for_completion
-        status = "InProgress"
-        Chef::Log.info "Waiting while status returns InProgress"
-        while status == "InProgress"
-          response = @rest.query_for_completion
-          ret_val = Nokogiri::XML response.body
-          status = xml_content(ret_val, "Status")
-          if status == "InProgress"
-            print "."
-            sleep(0.5)
-          elsif status == "Succeeded"
-            Chef::Log.debug "not InProgress : " + ret_val.to_xml
-          else
-            error_code, error_message = error_from_response_xml(ret_val)
-            Chef::Log.debug status + error_code + " : " + error_message if error_code.length > 0
-          end
-        end
-        ret_val
-      end
-    end
-  end
-end

data/lib/azure/service_management/deploy.rb

@@ -1,221 +0,0 @@
-#
-# Author:: Barry Davis (barryd@jetstreamsoftware.com)
-# Copyright:: Copyright (c) Chef Software Inc.
-# License:: Apache License, Version 2.0
-#
-# 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.
-#
-
-module Azure
-  class Deploys
-    include AzureUtility
-    def initialize(connection)
-      @connection = connection
-    end
-
-    # force_load should be true when there is something in local cache and we want to reload
-    # first call is always load.
-    def load(force_load = false)
-      unless @deploys || force_load
-        @deploys = begin
-          deploys = []
-          hosts = @connection.hosts.all
-          hosts.each do |host|
-            deploy = Deploy.new(@connection)
-            deploy.retrieve(host.name)
-            if deploy.name
-              host.add_deploy(deploy)
-              deploys << deploy
-            end
-          end
-          deploys
-        end
-      end
-      @deploys
-    end
-
-    def all
-      load
-    end
-
-    # TODO - Current knife-azure plug-in seems to have assumption that single hostedservice
-    # will always have one deployment (production). see Deploy#retrieve below
-    def get_deploy_name_for_hostedservice(hostedservicename)
-      host = @connection.hosts.find(hostedservicename)
-      if host && host.deploys.length > 0
-        host.deploys[0].name
-      else
-        nil
-      end
-    end
-
-    def create(params)
-      if params[:azure_connect_to_existing_dns]
-        unless @connection.hosts.exists?(params[:azure_dns_name])
-          Chef::Log.fatal "The specified Azure DNS Name does not exist."
-          exit 1
-        end
-      else
-        ret_val = @connection.hosts.create(params)
-        error_code, error_message = error_from_response_xml(ret_val)
-        if error_code.length > 0
-          Chef::Log.fatal "Unable to create DNS:" + error_code + " : " + error_message
-          exit 1
-        end
-      end
-      unless @connection.storageaccounts.exists?(params[:azure_storage_account])
-        @connection.storageaccounts.create(params)
-      end
-      if params[:ssh_identity_file]
-        params[:fingerprint] = @connection.certificates.create(params)
-      end
-      if params[:cert_path]
-        cert_data = File.read (params[:cert_path])
-        @connection.certificates.add cert_data, params[:cert_password], "pfx", params[:azure_dns_name]
-      elsif params[:winrm_ssl]
-        # TODO: generate certificates for ssl listener
-      end
-
-      params["deploy_name"] = get_deploy_name_for_hostedservice(params[:azure_dns_name])
-
-      if !params["deploy_name"].nil?
-        role = Role.new(@connection)
-        roleXML = role.setup(params)
-        ret_val = role.create(params, roleXML)
-      else
-        params["deploy_name"] = params[:azure_dns_name]
-        deploy = Deploy.new(@connection)
-        deployXML = deploy.setup(params)
-        ret_val = deploy.create(params, deployXML)
-      end
-      error_code, error_message = error_from_response_xml(ret_val)
-      if error_code.length > 0
-        Chef::Log.debug(ret_val.to_s)
-        raise Chef::Log.fatal "Unable to create role:" + error_code + " : " + error_message
-      end
-      @connection.roles.find_in_hosted_service(params[:azure_vm_name], params[:azure_dns_name])
-    end
-
-    def delete(rolename); end
-
-    def queryDeploy(hostedservicename)
-      deploy = Deploy.new(@connection)
-      deploy.retrieve(hostedservicename)
-      deploy
-    end
-  end
-
-  class Deploy
-    include AzureUtility
-    attr_accessor :connection, :name, :status, :url, :hostedservicename, :input_endpoints, :loadbalancers
-
-    def initialize(connection)
-      @connection = connection
-    end
-
-    def retrieve(hostedservicename)
-      @hostedservicename = hostedservicename
-      deployXML = @connection.query_azure("hostedservices/#{hostedservicename}/deploymentslots/Production")
-      if deployXML.at_css("Deployment Name") != nil
-        @name = xml_content(deployXML, "Deployment Name")
-        @status = xml_content(deployXML, "Deployment Status")
-        @url = xml_content(deployXML, "Deployment Url")
-        @roles = {}
-        rolesXML = deployXML.css("Deployment RoleInstanceList RoleInstance")
-        rolesListXML = deployXML.css("Deployment RoleList Role")
-        rolesXML.zip(rolesListXML).each do |roleXML, roleListXML|
-          role = Role.new(@connection)
-          role.parse(roleXML, hostedservicename, @name)
-          if role.publicipaddress.to_s.empty?
-            role.publicipaddress = xml_content(deployXML, "VirtualIPs VirtualIP Address")
-          end
-          role.parse_role_list_xml(roleListXML)
-          @roles[role.name] = role
-        end
-        @input_endpoints = []
-        endpointsXML = deployXML.css("InputEndpoint")
-        endpointsXML.each do |endpointXML|
-          @input_endpoints << parse_endpoint(endpointXML)
-        end
-        @loadbalancers = {}
-        lbsXML = deployXML.css("Deployment LoadBalancers LoadBalancer")
-        lbsXML.each do |lbXML|
-          loadbalancer = Loadbalancer.new(@connection)
-          loadbalancer.parse(lbXML, hostedservicename)
-          @loadbalancers[loadbalancer.name] = loadbalancer
-        end
-      end
-    end
-
-    def setup(params)
-      role = Role.new(@connection)
-      roleXML = role.setup(params)
-      builder = Nokogiri::XML::Builder.new do |xml|
-        xml.Deployment(
-          "xmlns" => "http://schemas.microsoft.com/windowsazure",
-          "xmlns:i" => "http://www.w3.org/2001/XMLSchema-instance"
-        ) do
-          xml.Name params["deploy_name"]
-          xml.DeploymentSlot "Production"
-          xml.Label Base64.encode64(params["deploy_name"]).strip
-          xml.RoleList { xml.Role("i:type" => "PersistentVMRole") }
-          if params[:azure_network_name]
-            xml.VirtualNetworkName params[:azure_network_name]
-          end
-        end
-      end
-      builder.doc.at_css("Role") << roleXML.at_css("PersistentVMRole").children.to_s
-      builder.doc
-    end
-
-    def create(params, deployXML)
-      servicecall = "hostedservices/#{params[:azure_dns_name]}/deployments"
-      @connection.query_azure(servicecall, "post", deployXML.to_xml)
-    end
-
-    # This parses endpoints from a RoleList-Role-InputEndpoint, NOT a RoleInstanceList-RoleInstance-InstanceEndpoint
-    # Refactor: make this an object rather than a hash..?
-    def parse_endpoint(inputendpoint_xml)
-      hash = {}
-      %w{LoadBalancedEndpointSetName LocalPort Name Port Protocol EnableDirectServerReturn LoadBalancerName IdleTimeoutInMinutes}.each do |key|
-        hash[key] = xml_content(inputendpoint_xml, key, nil)
-      end
-      # Protocol could be in there twice... If we have two, pick the second one as the first is for the probe.
-      if inputendpoint_xml.css("Protocol").count > 1
-        hash["Protocol"] = inputendpoint_xml.css("Protocol")[1].content
-      end
-      probe = inputendpoint_xml.css("LoadBalancerProbe")
-      if probe
-        hash["LoadBalancerProbe"] = {}
-        %w{Path Port Protocol IntervalInSeconds TimeoutInSeconds}.each do |key|
-          hash["LoadBalancerProbe"][key] = xml_content(probe, key, nil)
-        end
-      end
-      hash
-    end
-
-    def roles
-      @roles.values if @roles
-    end
-
-    # just delete from local cache
-    def delete_role_if_present(role)
-      @roles.delete(role.name) if @roles
-    end
-
-    def find_role(name)
-      @roles[name] if @roles
-    end
-
-  end
-end

data/lib/azure/service_management/disk.rb

@@ -1,68 +0,0 @@
-#
-# Author:: Barry Davis (barryd@jetstreamsoftware.com)
-# Copyright:: Copyright (c) Chef Software Inc.
-# License:: Apache License, Version 2.0
-#
-# 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.
-#
-
-module Azure
-  class Disks
-    def initialize(connection)
-      @connection = connection
-    end
-
-    def all
-      disks = []
-      response = @connection.query_azure("disks")
-      founddisks = response.css("Disk")
-      founddisks.each do |disk|
-        item = Disk.new(disk)
-        disks << item
-      end
-      disks
-    end
-
-    def find(name)
-      founddisk = nil
-      all.each do |disk|
-        next unless disk.name == name
-
-        founddisk = disk
-      end
-      founddisk
-    end
-
-    def exists(name)
-      !find(name).nil?
-    end
-
-    def clear_unattached
-      all.each do |disk|
-        next unless disk.attached == false
-
-        @connection.query_azure("disks/" + disk.name, "delete")
-      end
-    end
-  end
-end
-
-module Azure
-  class Disk
-    attr_accessor :name, :attached
-    def initialize(disk)
-      @name = disk.at_css("Name").content
-      @attached = !disk.at_css("AttachedTo").nil?
-    end
-  end
-end

data/lib/azure/service_management/host.rb

@@ -1,184 +0,0 @@
-#
-# Author:: Barry Davis (barryd@jetstreamsoftware.com)
-# Copyright:: Copyright (c) Chef Software Inc.
-# License:: Apache License, Version 2.0
-#
-# 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.
-#
-
-module Azure
-  class Hosts
-    include AzureUtility
-    def initialize(connection)
-      @connection = connection
-    end
-
-    # force_load should be true when there is something in local cache and we want to reload
-    # first call is always load.
-    def load(force_load = false)
-      unless @hosted_services || force_load
-        @hosted_services = begin
-          hosted_services = {}
-          responseXML = @connection.query_azure("hostedservices")
-          servicesXML = responseXML.css("HostedServices HostedService")
-          servicesXML.each do |serviceXML|
-            host = Host.new(@connection).parse(serviceXML)
-            hosted_services[host.name] = host
-          end
-          hosted_services
-        end
-      end
-      @hosted_services
-    end
-
-    def all
-      load.values
-    end
-
-    # first look up local cache if we have already loaded list.
-    def exists?(name)
-      return @hosted_services.key?(name) if @hosted_services
-
-      exists_on_cloud?(name)
-    end
-
-    # Look up on cloud and not local cache
-    def exists_on_cloud?(name)
-      ret_val = @connection.query_azure("hostedservices/#{name}")
-      error_code, error_message = error_from_response_xml(ret_val) if ret_val
-      if ret_val.nil? || error_code.length > 0
-        Chef::Log.debug("Unable to find hosted(cloud) service:" + error_code + " : " + error_message) if ret_val
-        false
-      else
-        true
-      end
-    end
-
-    # first look up local cache if we have already loaded list.
-    def find(name)
-      return @hosted_services[name] if @hosted_services && @hosted_services.key?(name)
-
-      fetch_from_cloud(name)
-    end
-
-    # Look up hosted service on cloud and not local cache
-    def fetch_from_cloud(name)
-      ret_val = @connection.query_azure("hostedservices/#{name}")
-      error_code, error_message = error_from_response_xml(ret_val) if ret_val
-      if ret_val.nil? || error_code.length > 0
-        Chef::Log.warn("Unable to find hosted(cloud) service:" + error_code + " : " + error_message) if ret_val
-        nil
-      else
-        Host.new(@connection).parse(ret_val)
-      end
-    end
-
-    def create(params)
-      host = Host.new(@connection)
-      host.create(params)
-    end
-
-    def delete(name)
-      if exists?(name)
-        servicecall = "hostedservices/" + name
-        @connection.query_azure(servicecall, "delete")
-      end
-    end
-  end
-end
-
-module Azure
-  class Host
-    include AzureUtility
-    attr_accessor :connection, :name, :url, :label
-    attr_accessor :dateCreated, :description, :location
-    attr_accessor :dateModified, :status
-
-    def initialize(connection)
-      @connection = connection
-      @deploys_loaded = false
-      @deploys = {}
-    end
-
-    def parse(serviceXML)
-      @name = xml_content(serviceXML, "ServiceName")
-      @url = xml_content(serviceXML, "Url")
-      @label = xml_content(serviceXML, "HostedServiceProperties Label")
-      @dateCreated = xml_content(serviceXML, "HostedServiceProperties DateCreated")
-      @description = xml_content(serviceXML, "HostedServiceProperties Description")
-      @location = xml_content(serviceXML, "HostedServiceProperties Location")
-      @dateModified = xml_content(serviceXML, "HostedServiceProperties DateLastModified")
-      @status = xml_content(serviceXML, "HostedServiceProperties Status")
-      self
-    end
-
-    def create(params)
-      builder = Nokogiri::XML::Builder.new do |xml|
-        xml.CreateHostedService("xmlns" => "http://schemas.microsoft.com/windowsazure") do
-          xml.ServiceName params[:azure_dns_name]
-          xml.Label Base64.encode64(params[:azure_dns_name])
-          xml.Description "Explicitly created hosted service"
-          unless params[:azure_service_location].nil?
-            xml.Location params[:azure_service_location]
-          end
-          unless params[:azure_affinity_group].nil?
-            xml.AffinityGroup params[:azure_affinity_group]
-          end
-        end
-      end
-      @connection.query_azure("hostedservices", "post", builder.to_xml)
-    end
-
-    def details
-      response = @connection.query_azure("hostedservices/" + @name + "?embed-detail=true")
-    end
-
-    # Deployments within this hostedservice
-    def add_deploy(deploy)
-      @deploys[deploy.name] = deploy
-    end
-
-    def delete_role(role)
-      deploys.each { |d| d.delete_role_if_present(role) }
-    end
-
-    def deploys
-      # check if we have deploys loaded, else load.
-      if (@deploys.length == 0) && !@deploys_loaded
-        deploy = Deploy.new(@connection)
-        deploy.retrieve(@name)
-        @deploys[deploy.name] = deploy
-        @deploys_loaded = true
-      end
-      @deploys.values
-    end
-
-    def roles
-      roles = []
-      deploys.each do |deploy|
-        roles.concat(deploy.roles) if deploy.roles
-      end
-      roles
-    end
-
-    def find_role(role_name, deploy_name = nil)
-      return @deploys[deploy_name].find_role(role_name) if deploy_name && deploys
-
-      # else lookup all deploys within hostedservice
-      deploys.each do |deploy|
-        role = deploy.find_role(role_name)
-        return role if role
-      end
-    end
-  end
-end