avst-cloud 0.1.13 → 0.1.14

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    OGU3ZWJiODcxNTczNjJhNGRkZGZlYmMxYTFkZjk0NDcyMzMzNTMyNA==
+    OGZhMjQwZjMyYjg1Y2I1OTQ4MWViOWZmZDNhOWZhZTMyOTEwYzBkYw==
   data.tar.gz: !binary |-
-    Nzg1ODhhZGI5OTU2YTcyZTNjNDBmMzI1ZjgzOTRiNDY2ZjAzZWZmYQ==
+    NjUzMWY4MTg1ZDdhZWZhM2JiMjdhYTZiMDc3YjlhZWJkOTBiNzEyNw==
 SHA512:
   metadata.gz: !binary |-
-    MGIyMmI1ZGM4OTA1OWJkNjFmOWQ2ZmY4ZWY4MzVlYzJhMjRhNGU4OGJlNGRm
-    YjgwZWRhZDAyMWVmNDUxZjhiMjc5YjAyZjcxNmE1ZTUzMGNlNzRiYmYzNDky
-    MDMyYTVjYTlkYjI0ZDE3MWM1NGM1OTA5OGUyNWQzMGM4ZTdhODM=
+    NjRkZTQ4NmUwNjQxNzA2OWJkMTNiNGRmYTk0ZTQ0YzM0MzVmYjEyYjZjMDc5
+    Y2FhOTAwMmE2MTE5OGFlOWE4NzYzZjVhODJlOTQzZDUzYTMwMDhhNTVmYTE4
+    YjRkYjQ3MmI5N2NlNTY5MTczMDQ3OGQ4YjVkYmE0MzA4NDJjMTY=
   data.tar.gz: !binary |-
-    MjI2NzA4MDM1ODExMGE3ZGIzZDNlOWI2OTQ2MDYwNzBkN2NjZTJjZmY2MzM3
-    YWI3YWZlYTZkODkyNTUwOGY5YTcyNzJlOGUwZGUwMzFjOGMxZmMzZTkzOTYw
-    ZTE2NGY1MjBhYTY4ZmIwNjRkNjVmYWIwOTZkMDk0NmJjZTdhMDk=
+    YzllYTEzYzgyYTcyOWVjOGFhMjA5YWM0MjVkZTRjZWQ1MzYyNTlmM2JiYzc4
+    ZjliY2ZjOTRiZmI2NzQ4YzlmYzM3OGZjODAyZDkwNmQ4ZTZiZTAwM2I4ODYx
+    OTk4MzBkZDhmYmExYzRlMDBmMzMxNTFkOWY2M2FmZjBjNzIzYTg=

data/README.md

@@ -75,6 +75,10 @@ The application depends on several gems listed in avst-cloud.gemspec file. Bundl
 
 See bin/avst-cloud-azure for examples
 
+### Azure RM
+
+Using new Azure Resource Manager way to manage resources. See bin/avst-cloud-azure-rm for examples
+
 ## Connecting to existing server
 
 ```

data/avst-cloud.gemspec

@@ -4,7 +4,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
     spec.name          = "avst-cloud"
-    spec.version       = '0.1.13'
+    spec.version       = '0.1.14'
     spec.authors       = ["Martin Brehovsky", "Jon Bevan", "Matthew Hope"]
     spec.email         = ["mbrehovsky@adaptavist.com", "jbevan@adaptavist.com", "mhope@adaptavist.com"]
     spec.summary       = %q{Automated creation, bootstrapping and provisioning of servers }
@@ -12,7 +12,7 @@ Gem::Specification.new do |spec|
     spec.homepage      = "http://www.adaptavist.com"
 
     spec.files         = `git ls-files -z`.split("\x0")
-    spec.executables   = ["avst-cloud", "avst-cloud-puppet", "avst-cloud-rackspace", "avst-cloud-azure"]
+    spec.executables   = ["avst-cloud", "avst-cloud-puppet", "avst-cloud-rackspace", "avst-cloud-azure", "avst-cloud-azure-rm"]
     spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
     spec.require_paths = ["lib"]
 
@@ -20,6 +20,7 @@ Gem::Specification.new do |spec|
     spec.add_development_dependency "rake"
     spec.add_dependency "fog"
     spec.add_dependency "fog-azure"
+    spec.add_dependency "fog-azure-rm"
     spec.add_dependency "azure"
     spec.add_dependency "capistrano", "3.2.1"
     spec.add_dependency "capistrano-rvm"

data/bin/avst-cloud

@@ -15,6 +15,8 @@
 # limitations under the License.
 
 require 'avst-cloud'
+require 'avst-cloud/aws_connection'
+require 'avst-cloud/aws_server'
 
 avst_cloud_base="#{File.expand_path("../../", __FILE__)}"
 
@@ -71,7 +73,7 @@ post_upload_commands = [
 remote_server_debug = true
 debug_structured_log = false
 
-server.bootstrap(pre_upload_commands, custom_file_uploads, post_upload_commands, remote_server_debug, debug_structured_log)
+server.bootstrap(pre_upload_commands, custom_file_uploads, post_upload_commands, remote_server_debug, debug_structured_log, false)
 
 git = "ssh://git@you_repo.git"
 branch = "master" 

data/bin/avst-cloud-azure

@@ -15,6 +15,8 @@
 # limitations under the License.
 
 require 'avst-cloud'
+require 'avst-cloud/azure_connection'
+require 'avst-cloud/azure_server'
 
 avst_cloud_base="#{File.expand_path("../../", __FILE__)}"
 
@@ -35,6 +37,7 @@ instance_type = nil
 storage_account_name = nil
 
 conn.list_known_servers
+
 server = conn.create_server(server_name, user, private_key_file, location, image_id, instance_type, storage_account_name)
 # fog_server = conn.find_fog_server(server_name)
 # server = AvstCloud::AzureServer.new(fog_server, server_name, nil, user, private_key_file)
@@ -69,7 +72,7 @@ post_upload_commands = [
 remote_server_debug = true
 debug_structured_log = false
 
-server.bootstrap(pre_upload_commands, custom_file_uploads, post_upload_commands, remote_server_debug, debug_structured_log)
+server.bootstrap(pre_upload_commands, custom_file_uploads, post_upload_commands, remote_server_debug, debug_structured_log, false)
 
 git = "ssh://git@you_repo.git"
 branch = "master" 

data/bin/avst-cloud-azure-rm

@@ -0,0 +1,136 @@
+#!/usr/bin/env ruby 
+
+# Copyright 2015 Adaptavist.com Ltd.
+#
+# 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 'avst-cloud'
+require 'avst-cloud/azure_rm_connection'
+require 'avst-cloud/azure_rm_server'
+avst_cloud_base="#{File.expand_path("../../", __FILE__)}"
+
+# FILL IN YOUR AZURE ACCOUNT DETAILS
+# See https://azure.microsoft.com/en-us/documentation/articles/resource-group-create-service-principal-portal/
+client_id = "" # Client ID:
+client_secret = "" # 2 Year Key: ...
+tenant_id = ""  # Tenant ID: ...
+subscription_id = "" # Subscription ID
+
+# Initiate connector object
+puts "Connection"
+
+conn = AvstCloud::AzureRmConnection.new(client_id, client_secret, tenant_id, subscription_id)
+# Lets create new Ubuntu 14 virtual machine 
+publisher = 'Canonical'
+offer = 'UbuntuServer'
+sku = '14.04.2-LTS'
+version = 'latest'
+
+server_name = "hostname1"
+user = "ubuntu"
+# Must comply to Azure pass guidelines
+password = "superSecretUbuntuPass111_@" 
+location = nil # Will default to West Europe
+resource_group = "new_resource_group" # if RG does not exists it will create it
+vm_size = nil # Defaults to Basic_A0
+storage_account_name = "new_storage_account" # creates it if not there
+network_interface_name = "new_network_interface" # creates it if not there, see defaults in azure_rm_connection
+virtual_network_name = "new_virtual_network" # creates it if not there, see defaults in azure_rm_connection
+subnet_name = nil # by default one gets created for new new network, if there is one we use it if more or none it fails 
+ip_configuration_name = "new_ip_config" # creates it if not there, see defaults in azure_rm_connection
+private_ip_allocation_method = "Dynamic"
+public_ip_allocation_method = "Static"
+subnet_address_list = nil
+dns_list = nil
+network_address_list = nil
+address_prefix  = nil
+use_public_ip = true # will return public ip, if set to false, private will be used by bootstrap
+serv = conn.create_server(server_name, 
+            user, 
+            password,
+            publisher,
+            offer,
+            sku,
+            version, 
+            location, 
+            resource_group, 
+            vm_size, 
+            storage_account_name, 
+            network_interface_name, 
+            virtual_network_name, 
+            subnet_name, 
+            ip_configuration_name, 
+            private_ip_allocation_method,
+            public_ip_allocation_method, 
+            subnet_address_list, 
+            dns_list, 
+            network_address_list, 
+            address_prefix,
+            use_public_ip)
+
+# serv = conn.server(server_name, resource_group ,user, password)
+# puts serv.inspect
+# serv.stop
+# puts serv.inspect
+# serv.start
+# puts serv.inspect
+# serv.destroy
+# puts serv.inspect
+
+pre_upload_commands = [
+    "echo 'pre_upload_command was here' >> /tmp/pre_upload",
+]
+
+custom_file_uploads = {
+    "#{avst_cloud_base}/files/id_rsa" => "/tmp/.",
+    "#{avst_cloud_base}/files/known_hosts" => "/tmp/."
+}
+
+# Uploading ssh keys to access git repo in provisioning stage, make sure you provide correct keys
+post_upload_commands = [
+    # "mkdir /home/#{user}/.ssh",
+    # "mv /tmp/id_rsa /home/#{user}/.ssh/.",
+    # "mv /tmp/known_hosts /home/#{user}/.ssh/.",
+    # "chmod 0600 /home/#{user}/.ssh/known_hosts",
+    # "chmod 0600 /home/#{user}/.ssh/id_rsa",
+    # "mkdir /var/opt/puppet",
+    # "chown #{user} /var/opt/puppet",
+    "apt-get update && apt-get install -o Dpkg::Options::='--force-confold' -f -y git puppet-common puppet",
+    "echo 'post_upload_command was here' >> /tmp/post_upload"
+]
+
+remote_server_debug = true
+debug_structured_log = false
+
+serv.bootstrap(pre_upload_commands, custom_file_uploads, post_upload_commands, remote_server_debug, debug_structured_log, true)
+
+git = "ssh://git@you_repo.git"
+branch = "master" 
+reference = nil # Tag
+# In this example we do not use puppet-runner, check doco
+puppet_runner = nil
+puppet_runner_prepare = nil
+custom_provisioning_commands = ["echo 'done' >> /tmp/done", "echo 'done' >> /tmp/done1"]
+server_tmp_folder="/tmp/avst_cloud_tmp_#{Time.now.to_i}"
+
+destination_folder = nil # defaults to /var/opt/puppet
+serv.provision(git, branch, server_tmp_folder, reference, custom_provisioning_commands, puppet_runner, puppet_runner_prepare, destination_folder)
+
+# serv.stop
+# serv.start
+
+custom_commands=nil
+server_tmp_folder="/tmp/done"
+serv.post_provisioning_cleanup(custom_commands, os, remote_server_debug, server_tmp_folder)
+# serv.destroy
+

data/bin/avst-cloud-puppet

@@ -14,6 +14,8 @@
 # limitations under the License.
 
 require 'avst-cloud'
+require 'avst-cloud/aws_connection'
+require 'avst-cloud/aws_server'
 
 avst_cloud_base ="#{File.expand_path("../../", __FILE__)}"
 
@@ -148,7 +150,7 @@ post_upload_commands = [
 remote_server_debug = true
 debug_structured_log = false
 
-server.bootstrap(pre_upload_commands, custom_file_uploads, post_upload_commands, remote_server_debug, debug_structured_log)
+server.bootstrap(pre_upload_commands, custom_file_uploads, post_upload_commands, remote_server_debug, debug_structured_log, false)
 
 server_tmp_folder = "/tmp/avst_cloud_tmp_#{Time.now.to_i}"
 

data/bin/avst-cloud-rackspace

@@ -15,6 +15,8 @@
 # limitations under the License.
 
 require 'avst-cloud'
+require 'avst-cloud/rackspace_connection'
+require 'avst-cloud/rackspace_server'
 
 avst_cloud_base="#{File.expand_path("../../", __FILE__)}"
 
@@ -59,7 +61,7 @@ post_upload_commands = [
 remote_server_debug = true
 debug_structured_log = false
 
-server.bootstrap(pre_upload_commands, custom_file_uploads, post_upload_commands, remote_server_debug, debug_structured_log)
+server.bootstrap(pre_upload_commands, custom_file_uploads, post_upload_commands, remote_server_debug, debug_structured_log, false)
 
 git = "ssh://git@you_repo.git"
 branch = "master" 

data/lib/avst-cloud.rb

@@ -12,19 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require_relative './avst-cloud/aws_connection.rb'
-require_relative './avst-cloud/aws_server.rb'
-require_relative './avst-cloud/azure_connection.rb'
-require_relative './avst-cloud/azure_server.rb'
-require_relative './avst-cloud/rackspace_connection.rb'
-require_relative './avst-cloud/rackspace_server.rb'
-require_relative './avst-cloud/logging.rb'
-require 'fog'
 require 'net/ssh'
 require 'net/scp'
 require 'uri'
 require 'colorize'
-
+require 'fog'
 module AvstCloud
-
 end

data/lib/avst-cloud/azure_rm_connection.rb

@@ -0,0 +1,515 @@
+# Copyright 2015 Adaptavist.com Ltd.
+#
+# 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 './cloud_connection.rb'
+require 'fog/azurerm'
+
+module AvstCloud
+    
+    class AzureRmConnection < AvstCloud::CloudConnection
+        
+        attr_accessor :tenant_id, :subscription_id
+
+        def initialize(client_id, client_secret, tenant_id, subscription_id)
+            super('AzureRM', client_id, client_secret)
+            @tenant_id = tenant_id
+            @subscription_id = subscription_id
+        end
+        
+        def server(server_name, resource_group, root_user, root_password, use_public_ip=true)
+            server = find_fog_server(server_name, resource_group)
+            if !root_user
+                root_user = get_root_user
+            end
+            ip_address = nil
+            if (server.network_interface_card_id)
+                network_interface_card_name = server.network_interface_card_id.split("/")[-1]
+                nic = connect_to_networks.network_interfaces(resource_group: resource_group).get(network_interface_card_name)
+                if nic
+                    if use_public_ip
+                        if nic.public_ip_address_id
+                            ip_configuration_name = nic.public_ip_address_id.split("/")[-1]
+                            pip = connect_to_networks.public_ips(resource_group: resource_group).get(ip_configuration_name)
+                            ip_address = pip.ip_address
+                        else
+                            logger.debug "Can not find public ip for server #{server_name} in resource_group #{resource_group}"
+                            raise "Can not find public ip"
+                        end
+                    else
+                        ip_address = nic.private_ip_address
+                    end
+                else
+                    logger.debug "Can not find network interface card for server #{server_name} in resource_group #{resource_group}"
+                    raise "Can not find network interface card"
+                end
+            else 
+                logger.debug "Can not find network interface card for server #{server_name} in resource_group #{resource_group}"
+                raise "Can not find network interface card"
+            end
+
+            AvstCloud::AzureRmServer.new(server, server_name, ip_address, root_user, root_password)
+        end
+
+        def create_server(server_name, 
+            user, 
+            password,
+            publisher,
+            offer,
+            sku,
+            version,
+            location, 
+            resource_group, 
+            vm_size, 
+            storage_account_name, 
+            network_interface_name, 
+            virtual_network_name, 
+            subnet_name, 
+            ip_configuration_name,
+            private_ip_allocation_method,
+            public_ip_allocation_method, 
+            subnet_address_list, 
+            dns_list, 
+            network_address_list, 
+            address_prefix,
+            use_public_ip)
+
+            location = location || 'West Europe'
+            user = user || get_root_user
+            vm_size = vm_size || "Basic_A0"
+            
+            # Check that resource_group exists if not create one
+            check_create_resource_group(resource_group, location)
+            
+            existing_server = find_fog_server(server_name, resource_group, false)
+            
+            if existing_server
+                logger.error "Server #{server_name} found. #{existing_server.inspect}".yellow
+                raise "Running server with the same name found!"
+            else
+                logger.debug "Creating Azure server:"
+                logger.debug "Server name          - #{server_name}"
+                logger.debug "location             - #{location}"
+                logger.debug "storage_account_name - #{storage_account_name}"
+                logger.debug "vm_size              - #{vm_size}"
+                logger.debug "user                 - #{user}"
+                logger.debug "password             - #{password}"
+                logger.debug "publisher            - #{publisher}"
+                logger.debug "offer                - #{offer}"
+                logger.debug "sku                  - #{sku}"
+                logger.debug "version              - #{version}"
+
+                # Check that storage_account exists if not create one
+                check_create_storage_account(storage_account_name, location, resource_group)
+                
+                # Check if network_interface_card_id exists if not create one
+                # If not, create one for virtual network provided with subnet, security group and also public ip name
+                ip_address = check_create_network_interface(network_interface_name, resource_group, location, virtual_network_name, subnet_name, ip_configuration_name, private_ip_allocation_method, public_ip_allocation_method, subnet_address_list, dns_list, network_address_list, address_prefix, use_public_ip)
+                
+                # create server
+                server = connect.servers.create(
+                    name: server_name,
+                    location: location,
+                    resource_group: resource_group,
+                    vm_size: vm_size,
+                    storage_account_name: storage_account_name,
+                    username: user,
+                    password: password,
+                    disable_password_authentication: false,
+                    network_interface_card_id: "/subscriptions/#{@subscription_id}/resourceGroups/#{resource_group}/providers/Microsoft.Network/networkInterfaces/#{network_interface_name}",
+                    publisher: publisher,
+                    offer: offer,
+                    sku: sku,
+                    version: version
+                )
+                
+                result_server = AvstCloud::AzureRmServer.new(server, server_name, ip_address, user, password)
+                logger.debug "[DONE]\n\n"
+                logger.debug "The server has been successfully created, to login onto the server:\n"
+                logger.debug "\t ssh #{user}@#{ip_address} with pass #{password} \n"
+                result_server
+            end
+        end
+
+        def list_storage_accounts(storage_account_name, resource_group)
+            storage_acc = connect_to_storages.storage_accounts(resource_group: resource_group)
+                          .get(storage_account_name)
+            logger.debug "#{storage_acc.inspect}"
+        end
+
+        def check_create_network_interface(network_interface_name, resource_group, location, virtual_network_name, subnet_name, ip_configuration_name, private_ip_allocation_method="Dynamic", public_ip_allocation_method="Static", subnet_address_list=nil, dns_list=nil, network_address_list=nil, address_prefix=nil, use_public_ip=true)
+            nic = connect_to_networks.network_interfaces(resource_group: resource_group).get(network_interface_name)
+        
+            # check/create ip_configuration_name exists
+            public_ip = check_create_ip_configuration(ip_configuration_name, resource_group, location, public_ip_allocation_method)
+            unless nic
+                # check/create  virtual_network exists
+                vnet = check_create_virtual_network(virtual_network_name, resource_group, location, subnet_address_list, dns_list, network_address_list)
+                
+                # check if provided subnet exists, if nil then use default one
+                unless subnet_name                    
+                    subnets = connect_to_networks.subnets(resource_group: resource_group, virtual_network_name: virtual_network_name)
+                    if subnets.length == 0
+                        raise "Can not decide what subnet to choose. There are no subnets for virtual network #{virtual_network_name}."
+                    elsif subnets.length != 1
+                        raise "Can not decide what subnet to choose. Please specify subnet name."
+                    end
+                    subnet_name = subnets[0].name
+                    logger.debug "Using subnet #{subnet_name}"
+                end
+                
+                nic = connect_to_networks.network_interfaces.create(
+                    name: network_interface_name,
+                    resource_group: resource_group,
+                    location: location,
+                    subnet_id: "/subscriptions/#{@subscription_id}/resourceGroups/#{resource_group}/providers/Microsoft.Network/virtualNetworks/#{virtual_network_name}/subnets/#{subnet_name}",
+                    public_ip_address_id: "/subscriptions/#{@subscription_id}/resourceGroups/#{resource_group}/providers/Microsoft.Network/publicIPAddresses/#{ip_configuration_name}",
+                    ip_configuration_name: ip_configuration_name,
+                    private_ip_allocation_method: private_ip_allocation_method
+                )
+            end
+            if use_public_ip
+                public_ip
+            else
+                nic.private_ip_address
+            end
+        end
+        
+        def find_network_interface_for_server(server_name, resource_group, should_fail=false)
+            server = find_fog_server(server_name, resource_group)
+            network_interface = nil
+            if (server and server.network_interface_card_id)
+                network_interface_card_name = server.network_interface_card_id.split("/")[-1]
+                network_interface = connect_to_networks.network_interfaces(resource_group: resource_group).get(network_interface_card_name)
+            else
+                logger.debug "Can not find network interface card for server #{server_name} in resource_group #{resource_group}"
+                raise "Can not find network interface card" if should_fail 
+            end
+            network_interface
+        end
+
+        def destroy_network_interface(network_interface_name, resource_group)
+            logger.debug "Deleting #{network_interface_name}"
+            network_interface = connect_to_networks.network_interfaces(resource_group: resource_group).get(network_interface_name)
+            if network_interface
+                network_interface.destroy
+            end
+            logger.debug "Network interface deleted"
+        end
+
+        def destroy_network_interface_for_server(server_name, resource_group, should_fail=false)
+            server = find_fog_server(server_name, resource_group)
+            if (server.network_interface_card_id)
+                network_interface_card_name = server.network_interface_card_id.split("/")[-1]
+                destroy_network_interface(network_interface_card_name, resource_group)
+            else 
+                logger.debug "Can not find network interface card for server #{server_name} in resource_group #{resource_group}"
+                raise "Can not find network interface card" if should_fail
+            end
+        end
+
+        def check_create_ip_configuration(ip_configuration_name, resource_group, location, public_ip_allocation_method="Static")
+            ip_configuration = connect_to_networks.public_ips(resource_group: resource_group).get(ip_configuration_name)
+            unless ip_configuration
+                ip_configuration = connect_to_networks.public_ips.create(
+                    name: ip_configuration_name,
+                    resource_group: resource_group,
+                    location: location,
+                    public_ip_allocation_method: public_ip_allocation_method
+                )
+            end
+            ip_configuration.ip_address
+        end
+
+        def destroy_ip_configuration(ip_configuration_name, resource_group)
+            logger.debug "Deleting #{ip_configuration_name}"
+            public_ip = connect_to_networks.public_ips(resource_group: resource_group).get(ip_configuration_name)
+            if public_ip
+                public_ip.destroy
+            end
+            logger.debug "Public IP deleted"
+        end
+
+        def destroy_ip_configuration_for_server(server_name, resource_group, should_fail=false)
+            server = find_fog_server(server_name, resource_group)
+            if (server.network_interface_card_id)
+                network_interface_card_name = server.network_interface_card_id.split("/")[-1]
+                nic = connect_to_networks.network_interfaces(resource_group: resource_group).get(network_interface_card_name)
+                if nic
+                    if nic.public_ip_address_id
+                        ip_configuration_name = nic.public_ip_address_id.split("/")[-1]
+                        destroy_ip_configuration(ip_configuration_name, resource_group)
+                    else
+                        logger.debug "Can not find public ip for server #{server_name} in resource_group #{resource_group}"
+                        raise "Can not find public ip" if should_fail
+                    end
+                else
+                    logger.debug "Can not find network interface card for server #{server_name} in resource_group #{resource_group}"
+                    raise "Can not find network interface card" if should_fail
+                end
+            else 
+                logger.debug "Can not find network interface card for server #{server_name} in resource_group #{resource_group}"
+                raise "Can not find network interface card" if should_fail
+            end
+        end
+
+        def check_create_subnet(subnet_name, resource_group, location, virtual_network_name, address_prefix=nil, subnet_address_list=nil, dns_list=nil, network_address_list=nil)
+            subnet = connect_to_networks.subnets(resource_group: resource_group, virtual_network_name: virtual_network_name).get(subnet_name)
+            unless subnet
+                logger.debug "Subnet #{subnet_name} not found, creating new one"
+                address_prefix = address_prefix || '10.1.0.0/24'                
+                subnet = connect_to_networks.subnets.create(
+                    name: subnet_name,
+                    resource_group: resource_group,
+                    virtual_network_name: virtual_network_name,
+                    address_prefix: address_prefix
+                )
+            end
+        end
+
+        def destroy_subnet(subnet_name, resource_group, virtual_network_name)
+            logger.debug "Deleting #{subnet_name}"
+            subnet = connect_to_networks.subnets(resource_group: resource_group, virtual_network_name: virtual_network_name).get(subnet_name)
+            if subnet
+                subnet.destroy
+            end
+            logger.debug "Subnet deleted"
+        end
+
+        def destroy_subnet_for_server(server_name, resource_group, should_fail=false)
+            server = find_fog_server(server_name, resource_group)
+            if (server.network_interface_card_id)
+                network_interface_card_name = server.network_interface_card_id.split("/")[-1]
+                nic = connect_to_networks.network_interfaces(resource_group: resource_group).get(network_interface_card_name)
+                if nic
+                    if nic.subnet_id
+                        subnet_id_name = nic.subnet_id.split("/")[-1]
+                        virtual_network_name = nic.subnet_id.split("virtualNetworks/")[-1].split("/")[0]
+                        destroy_subnet(subnet_id_name, resource_group, virtual_network_name)
+                    else
+                        logger.debug "Can not find subnet for server #{server_name} in resource_group #{resource_group}"
+                        raise "Can not find subnet" if should_fail
+                    end
+                else
+                    logger.debug "Can not find network interface card for server #{server_name} in resource_group #{resource_group}"
+                    raise "Can not find network interface card" if should_fail
+                end
+            else 
+                logger.debug "Can not find network interface card for server #{server_name} in resource_group #{resource_group}"
+                raise "Can not find network interface card" if should_fail
+            end
+        end
+
+        def check_create_virtual_network(virtual_network_name, resource_group, location, subnet_address_list=nil, dns_list=nil, network_address_list=nil)
+            vnet = connect_to_networks.virtual_networks(resource_group: resource_group).get(virtual_network_name)
+                                       # virtual_networks.get(virtual_network_name, resource_group)
+            unless vnet
+                logger.debug "Virtual network #{virtual_network_name} not found, creating new one"
+                subnet_address_list = subnet_address_list || '10.1.0.0/24'
+                dns_list = dns_list || '8.8.8.8,8.8.4.4,10.1.0.5,10.1.0.6'
+                network_address_list = network_address_list || '10.1.0.0/16,10.2.0.0/16'
+                vnet = connect_to_networks.virtual_networks.create(
+                    name: virtual_network_name,
+                    location: location,
+                    resource_group: resource_group,
+                    subnet_address_list: subnet_address_list,
+                    dns_list: dns_list,
+                    network_address_list: network_address_list
+                )
+            end
+            vnet
+        end
+
+        def destroy_virtual_network_for_server(server_name, resource_group, should_fail=false)
+            server = find_fog_server(server_name, resource_group)
+            if (server.network_interface_card_id)
+                network_interface_card_name = server.network_interface_card_id.split("/")[-1]
+                nic = connect_to_networks.network_interfaces(resource_group: resource_group).get(network_interface_card_name)
+                if nic
+                    if nic.subnet_id
+                        virtual_network_name = nic.subnet_id.split("virtualNetworks/")[-1].split("/")[0]
+                        destroy_virtual_network(virtual_network_name, resource_group)
+                    else
+                        logger.debug "Can not find virtual network for server #{server_name} in resource_group #{resource_group}"
+                        raise "Can not find subnet" if should_fail
+                    end
+                else
+                    logger.debug "Can not find network interface card for server #{server_name} in resource_group #{resource_group}"
+                    raise "Can not find network interface card" if should_fail
+                end
+            else 
+                logger.debug "Can not find network interface card for server #{server_name} in resource_group #{resource_group}"
+                raise "Can not find network interface card" if should_fail
+            end
+        end
+
+        def destroy_virtual_network(virtual_network_name, resource_group)
+            logger.debug "Deleting #{virtual_network_name}"
+            vnet = connect_to_networks.virtual_networks(resource_group: resource_group).get(virtual_network_name)
+            if vnet
+                vnet.destroy
+            end
+            logger.debug "Virtual network deleted"
+        end
+
+        def check_create_storage_account(storage_account_name, location, resource_group)
+            account = connect_to_storages.storage_accounts(resource_group: resource_group).get(storage_account_name)
+            unless account
+                logger.debug "Storage account #{storage_account_name} not found, creating new one"
+                account = connect_to_storages.storage_accounts.create(
+                    name:     storage_account_name,
+                    location: location,
+                    resource_group: resource_group
+                )
+            end
+            account
+        end
+
+        def find_storage_account_name_for_server(server_name, resource_group, should_fail=false)
+            server = find_fog_server(server_name, resource_group)
+            storage_account_name = nil
+            if (server and server.storage_account_name)
+                storage_account_name = server.storage_account_name
+            end
+            storage_account_name
+        end
+
+        def destroy_storage_account_for_server(server_name, resource_group, should_fail=false)
+            server = find_fog_server(server_name, resource_group)
+            if (server.storage_account_name)
+                storage_account_name = server.storage_account_name
+                destroy_storage_account(storage_account_name, resource_group)
+            else 
+                logger.debug "Can not find storage account for server #{server_name} in resource_group #{resource_group}"
+                raise "Can not find storage account" if should_fail
+            end
+        end
+
+        def destroy_storage_account(storage_account_name, resource_group)
+            logger.debug "Deleting #{storage_account_name}"
+            account = connect_to_storages.storage_accounts(resource_group: resource_group).get(storage_account_name)
+            if account
+                account.destroy
+            end
+            logger.debug "Storage deleted"
+        end
+
+        def check_create_resource_group(resource_group, location)
+            logger.debug "Searching for #{resource_group}"
+            found_resource_group = connect_to_resources.resource_groups.get(resource_group)
+            unless found_resource_group
+                logger.debug "Resource group #{resource_group} not found, creating new one"
+                found_resource_group = connect_to_resources.resource_groups.create(
+                    name:     resource_group,
+                    location: location
+                )
+            end
+            found_resource_group
+        end
+
+        def destroy_resource_group(resource_group)
+            logger.debug "Deleting #{resource_group}"
+            found_resource_group = connect_to_resources.resource_groups.get(resource_group)
+            if found_resource_group
+                found_resource_group.destroy
+            end
+        end
+
+        def server_status(server_name, resource_group)
+            connect.servers(resource_group: resource_group).get(server_name).vm_status
+        end
+
+        def list_images
+            connect.images.each do |im|
+                logger.debug im.inspect
+            end
+        end
+        
+        # Returns list of servers from fog
+        def list_known_servers(resource_group)
+            connect.servers(resource_group: resource_group).each do |sr|
+                logger.debug sr.inspect
+            end
+        end
+
+        def find_fog_server(server_name, resource_group, should_fail=true)
+            serv = connect.servers(resource_group: resource_group).get(server_name)
+            unless serv
+                if should_fail
+                    logger.debug "Server not found for name: #{server_name} in resource group #{resource_group}"
+                    raise "Server not found for name: #{server_name} in resource group #{resource_group}"
+                end
+            end
+            serv
+        end
+
+    private
+        def get_root_user
+            "azureuser"
+        end
+        def connect
+            unless @connection
+                logger.debug "Creating new connection to Azure"
+                
+                @connection = Fog::Compute.new(
+                    provider: 'AzureRM',
+                    tenant_id: @tenant_id,
+                    client_id:    @provider_access_user,
+                    client_secret: @provider_access_pass,
+                    subscription_id: @subscription_id
+                )
+            end
+            @connection
+        end
+
+        def connect_to_networks
+            unless @networks_connection
+                logger.debug "Creating new connection to Azure networks"
+                @networks_connection = Fog::Network::AzureRM.new(
+                    tenant_id: @tenant_id,
+                    client_id:    @provider_access_user,
+                    client_secret: @provider_access_pass,
+                    subscription_id: @subscription_id
+                )
+            end
+            @networks_connection
+        end
+
+        def connect_to_storages
+            unless @storage_connection
+                logger.debug "Creating new connection to Azure storage accounts"
+                @storage_connection = Fog::Storage.new(
+                    provider: 'AzureRM',
+                    tenant_id: @tenant_id,
+                    client_id:    @provider_access_user,
+                    client_secret: @provider_access_pass,
+                    subscription_id: @subscription_id
+                )
+            end
+            @storage_connection
+        end
+
+        def connect_to_resources
+            unless @resources_connection
+                logger.debug "Creating new connection to Azure resources"
+                @resources_connection = Fog::Resources::AzureRM.new(
+                    tenant_id: @tenant_id,
+                    client_id:    @provider_access_user,
+                    client_secret: @provider_access_pass,
+                    subscription_id: @subscription_id
+                )
+            end
+            @resources_connection
+        end
+    end
+end

data/lib/avst-cloud/azure_rm_server.rb

@@ -0,0 +1,53 @@
+# Copyright 2015 Adaptavist.com Ltd.
+#
+# 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 './cloud_server.rb'
+
+module AvstCloud
+    class AzureRmServer < AvstCloud::CloudServer
+
+        def stop
+            if @server
+                logger.debug "Stopping #{@server_name}"
+                @server.power_off
+                logger.debug "[DONE]\n\n"
+                logger.debug "Server #{@server_name} stopped...".green
+            else
+                raise "Server #{@server_name} does not exist!".red
+            end
+        end
+
+        def start
+            if @server
+                logger.debug "Starting #{@server_name}"
+                @server.start
+                logger.debug "[DONE]\n\n"
+                logger.debug "Server #{@server_name} started...".green
+            else
+                raise "Server #{@server_name} does not exist!".red
+            end
+        end
+
+        def destroy
+            if @server
+                logger.debug "Killing #{@server_name}"
+                @server.destroy
+                logger.debug "Server #{@server_name} destroyed...".green
+            else
+                raise "Server #{@server_name} does not exist!".red
+            end
+        end
+
+    end
+end

data/lib/avst-cloud/cloud_server.rb

@@ -28,10 +28,10 @@ module AvstCloud
             @access_password = access_password
         end 
 
-        def bootstrap(pre_upload_commands, custom_file_uploads, post_upload_commands, remote_server_debug, debug_structured_log)
+        def bootstrap(pre_upload_commands, custom_file_uploads, post_upload_commands, remote_server_debug, debug_structured_log, enable_sudo="false")
             logger.debug "Bootstrapping #{server_name}...".green
             run_tasks([AvstCloud::WaitUntilReady.new])
-            disable_tty_task = AvstCloud::DisableRequireTty.new(@access_user)
+            disable_tty_task = AvstCloud::DisableRequireTty.new(@access_user, @access_password, enable_sudo)
             pre_upload_commands_tasks = AvstCloud::SshCommandTask.new(pre_upload_commands, remote_server_debug, debug_structured_log)
             custom_file_uploads_tasks = AvstCloud::ScpTask.new(custom_file_uploads)
             post_upload_commands_tasks = AvstCloud::SshCommandTask.new(post_upload_commands, remote_server_debug, debug_structured_log)

data/lib/avst-cloud/task.rb

@@ -105,32 +105,50 @@ module AvstCloud
 
     # In case Requiretty is set in sudoers disable it for bootstrapping and provisioning
     # for user that performs it
+    # In case user does not have sudo no pass, enable it for bootstrapping and provisioning
     class DisableRequireTty < AvstCloud::SshTask
         include Logging
-        def initialize(for_user)
+        def initialize(for_user, pass, enable_passwordless_sudo=false)
             @for_user = for_user
+            @user_password = pass
+            @enable_passwordless_sudo = enable_passwordless_sudo
         end
         def ssh_command(session)
+            commands = []
+            if @enable_passwordless_sudo
+                commands << "sudo su -c 'echo \"#{@for_user} ALL=(ALL) NOPASSWD: ALL\" > /etc/sudoers.d/zzz_#{@for_user}'"
+                redirect_type = ">>"
+            else
+                redirect_type = ">"
+            end
+
+            commands << "sudo su -c 'echo \"Defaults:#{@for_user} !requiretty\" #{redirect_type} /etc/sudoers.d/zzz_#{@for_user}'"
+            
             session.open_channel do |channel|
                 channel.request_pty do |ch, success|
                     raise 'Error requesting pty' unless success
+                end
+                channel.exec(commands.join(';')) do |ch, success|
+                    abort "Could not execute commands!" unless success
 
-                    ch.send_channel_request('shell') do |ch, success|
-                        raise 'Error opening shell' unless success
+                    channel.on_data do |ch, data|
+                        if @debug
+                            STDOUT.print  "#{data}"
+                        end
+                        channel.send_data "#{@user_password}\n" if data =~ /password/
                     end
-                end
-                channel.on_data do |ch, data|
-                    if @debug
-                        STDOUT.print data
+                    channel.on_extended_data do |ch, type, data|
+                        STDOUT.print "stderr: #{data}"
+                    end
+
+                    channel.on_close do |ch|
+                        if @debug
+                            STDOUT.print "Channel is closing!"
+                        end
                     end
                 end
-                channel.on_extended_data do |ch, type, data|
-                    STDOUT.print "Error: #{data}\n"
-                end
-                channel.send_data("sudo su -c 'echo 'Defaults:#{@for_user}\\ \\!requiretty' >> /etc/sudoers'\n")
-                channel.send_data("exit\n")
-                session.loop
             end
+            session.loop
         end
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: avst-cloud
 version: !ruby/object:Gem::Version
-  version: 0.1.13
+  version: 0.1.14
 platform: ruby
 authors:
 - Martin Brehovsky
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-15 00:00:00.000000000 Z
+date: 2016-06-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -68,6 +68,20 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: fog-azure-rm
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: azure
   requirement: !ruby/object:Gem::Requirement
@@ -190,6 +204,7 @@ executables:
 - avst-cloud-puppet
 - avst-cloud-rackspace
 - avst-cloud-azure
+- avst-cloud-azure-rm
 extensions: []
 extra_rdoc_files: []
 files:
@@ -202,6 +217,7 @@ files:
 - avst-cloud.gemspec
 - bin/avst-cloud
 - bin/avst-cloud-azure
+- bin/avst-cloud-azure-rm
 - bin/avst-cloud-puppet
 - bin/avst-cloud-rackspace
 - config/custom_system_config/hiera-configs/defaults/example.yaml
@@ -214,6 +230,8 @@ files:
 - lib/avst-cloud/aws_connection.rb
 - lib/avst-cloud/aws_server.rb
 - lib/avst-cloud/azure_connection.rb
+- lib/avst-cloud/azure_rm_connection.rb
+- lib/avst-cloud/azure_rm_server.rb
 - lib/avst-cloud/azure_server.rb
 - lib/avst-cloud/cloud_connection.rb
 - lib/avst-cloud/cloud_server.rb