gitlab-fog-google 1.13.0

data/lib/fog/compute/google/requests/remove_target_pool_instance.rb

@@ -0,0 +1,30 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def remove_target_pool_instances(_target_pool, _region, _instances)
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        def remove_target_pool_instances(target_pool, region, instances)
+          instance_lst = instances.map do |instance|
+            ::Google::Apis::ComputeV1::InstanceReference.new(:instance => instance)
+          end
+
+          @compute.remove_target_pool_instance(
+            @project,
+            region.split("/")[-1],
+            target_pool,
+            ::Google::Apis::ComputeV1::RemoveTargetPoolsInstanceRequest.new(
+              :instances => instance_lst
+            )
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/google/requests/remove_target_pool_instances.rb

@@ -0,0 +1,30 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def remove_target_pool_instances(_target_pool, _region, _instances)
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        def remove_target_pool_instances(target_pool, region, instances)
+          instance_lst = instances.map do |link|
+            ::Google::Apis::ComputeV1::InstanceReference.new(
+              :instance => link
+            )
+          end
+
+          @compute.remove_target_pool_instance(
+            @project, region.split("/")[-1], target_pool,
+            ::Google::Apis::ComputeV1::RemoveTargetPoolsInstanceRequest.new(
+              :instances => instance_lst
+            )
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/google/requests/reset_server.rb

@@ -0,0 +1,19 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def reset_server(_identity, _zone)
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        def reset_server(identity, zone)
+          @compute.reset_instance(@project, zone.split("/")[-1], identity)
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/google/requests/reset_windows_password.rb

@@ -0,0 +1,154 @@
+# Copyright 2015 Google Inc. All Rights Reserved.
+#
+# 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.
+#
+# Changes:
+# March 2020: Modified example found here:
+# https://github.com/GoogleCloudPlatform/compute-image-windows/blob/master/examples/windows_auth_python_sample.py
+# to enable fog-google to change windows passwords.
+
+require "openssl"
+require "base64"
+require "json"
+
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def reset_windows_password(_server:, _user:)
+          Fog::Mock.not_implemented
+        end
+      end
+
+      class Real
+        ##
+        # Resets Windows passwords for users on Google's Windows based images.  Code based on Google provided example.
+        #
+        # @param instance [String] the name of the instance
+        # @param zone [String] the name of the zone of the instance
+        # @param user [String] the user whose password should be reset
+        #
+        # @return [String] new password
+        #
+        # @see https://cloud.google.com/compute/docs/instances/windows/automate-pw-generation
+        def reset_windows_password(server:, user:)
+          # Pull the e-mail address of user authenticated to API
+          email = @compute.request_options.authorization.issuer
+
+          # Create a new key
+          key = OpenSSL::PKey::RSA.new(2048)
+          modulus, exponent = get_modulus_exponent_in_base64(key)
+
+          # Get Old Metadata
+          old_metadata = server.metadata
+
+          # Create JSON Object with needed information
+          metadata_entry = get_json_string(user, modulus, exponent, email)
+
+          # Create new metadata object
+          new_metadata = update_windows_keys(old_metadata, metadata_entry)
+
+          # Set metadata on instance
+          server.set_metadata(new_metadata, false)
+
+          # Get encrypted password from Serial Port 4 Output
+
+          # If machine is booting for the first time, there appears to be a
+          # delay before the password appears on the serial port.
+          sleep(1) until server.ready?
+          serial_port_output = server.serial_port_output(:port => 4)
+          loop_cnt = 0
+          while serial_port_output.empty?
+            if loop_cnt > 12
+              Fog::Logger.warning("Encrypted password never found on Serial Output Port 4")
+              raise "Could not reset password."
+            end
+            sleep(5)
+            serial_port_output = server.serial_port_output(:port => 4)
+            loop_cnt += 1
+          end
+
+          # Parse and decrypt password
+          enc_password = get_encrypted_password_from_serial_port(serial_port_output, modulus)
+          password = decrypt_password(enc_password, key)
+
+          return password
+        end
+
+        def get_modulus_exponent_in_base64(key)
+          mod = [key.n.to_s(16)].pack("H*").strip
+          exp = [key.e.to_s(16)].pack("H*").strip
+          modulus = Base64.strict_encode64(mod).strip
+          exponent = Base64.strict_encode64(exp).strip
+          return modulus, exponent
+        end
+
+        def get_expiration_time_string
+          utc_now = Time.now.utc
+          expire_time = utc_now + 5 * 60
+          return expire_time.strftime("%Y-%m-%dT%H:%M:%SZ")
+        end
+
+        def get_json_string(user, modulus, exponent, email)
+          expire = get_expiration_time_string
+          data = { 'userName': user,
+                   'modulus': modulus,
+                   'exponent': exponent,
+                   'email': email,
+                   'expireOn': expire }
+          return ::JSON.dump(data)
+        end
+
+        def update_windows_keys(old_metadata, metadata_entry)
+          if old_metadata[:items]
+            new_metadata = Hash[old_metadata[:items].map { |item| [item[:key], item[:value]] }]
+          else
+            new_metadata = {}
+          end
+          new_metadata["windows-keys"] = metadata_entry
+          return new_metadata
+        end
+
+        def get_encrypted_password_from_serial_port(serial_port_output, modulus)
+          output = serial_port_output.split("\n")
+          output.reverse_each do |line|
+            begin
+              if line.include?("modulus") && line.include?("encryptedPassword")
+                entry = ::JSON.parse(line)
+                if modulus == entry["modulus"]
+                  return entry["encryptedPassword"]
+                end
+              else
+                next
+              end
+            rescue ::JSON::ParserError
+              Fog::Logger.warning("Parsing encrypted password from serial output
+                                  failed. Trying to parse next matching line.")
+              next
+            end
+          end
+        end
+
+        def decrypt_password(enc_password, key)
+          decoded_password = Base64.strict_decode64(enc_password)
+          begin
+            return key.private_decrypt(decoded_password, OpenSSL::PKey::RSA::PKCS1_OAEP_PADDING)
+          rescue OpenSSL::PKey::RSAError
+            Fog::Logger.warning("Error decrypting password received from Google.
+                                Maybe check output on Serial Port 4 and Metadata key: windows-keys?")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/google/requests/set_common_instance_metadata.rb

@@ -0,0 +1,23 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def set_common_instance_metadata(_project, _current_fingerprint, _metadata = {})
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        def set_common_instance_metadata(project, current_fingerprint, metadata = {})
+          metadata_obj = ::Google::Apis::ComputeV1::Metadata.new(
+            :fingerprint => current_fingerprint,
+            :items => metadata.map { |k, v| { :key => k, :value => v } }
+          )
+          @compute.set_common_instance_metadata(project, metadata_obj)
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/google/requests/set_forwarding_rule_target.rb

@@ -0,0 +1,23 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def set_forwarding_rule_target(_rule_name, _region, _target_opts)
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        def set_forwarding_rule_target(rule_name, region, target_opts)
+          region = region.split("/")[-1] if region.start_with? "http"
+          @compute.set_forwarding_rule_target(
+            @project, region, rule_name,
+            ::Google::Apis::ComputeV1::TargetReference.new(target_opts)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/google/requests/set_global_forwarding_rule_target.rb

@@ -0,0 +1,22 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def set_global_forwarding_rule_target(_rule_name, _target)
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        def set_global_forwarding_rule_target(rule_name, target_opts)
+          @compute.set_global_forwarding_rule_target(
+            @project, rule_name,
+            ::Google::Apis::ComputeV1::TargetReference.new(target_opts)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/google/requests/set_instance_template.rb

@@ -0,0 +1,28 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def set_instance_template(_instance_group_manager, _instance_template)
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        def set_instance_template(instance_group_manager, instance_template)
+          request = ::Google::Apis::ComputeV1::InstanceGroupManagersSetInstanceTemplateRequest.new(
+            :instance_template => instance_template.class == String ? instance_template : instance_template.self_link
+          )
+          if instance_group_manager.zone
+            zone = instance_group_manager.zone.split("/")[-1]
+            @compute.set_instance_group_manager_instance_template(@project, zone, instance_group_manager.name, request)
+          else
+            region = instance_group_manager.region.split("/")[-1]
+            @compute.set_region_instance_group_manager_instance_template(@project, region, instance_group_manager.name, request)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/google/requests/set_server_disk_auto_delete.rb

@@ -0,0 +1,26 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def set_server_disk_auto_delete(_identity, _zone, _auto_delete, _device_name)
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        # @see https://cloud.google.com/compute/docs/reference/latest/instances/setDiskAutoDelete
+        def set_server_disk_auto_delete(identity, zone, auto_delete, device_name)
+          @compute.set_disk_auto_delete(
+            @project,
+            zone.split("/")[-1],
+            identity,
+            auto_delete,
+            device_name
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/google/requests/set_server_machine_type.rb

@@ -0,0 +1,23 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def set_server_machine_type(_instance, _zone, _machine_type)
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        def set_server_machine_type(instance, zone, machine_type)
+          request = ::Google::Apis::ComputeV1::InstancesSetMachineTypeRequest.new
+          zone = zone.split("/")[-1]
+          machine_type = machine_type.split("/")[-1]
+          request.machine_type = "zones/#{zone}/machineTypes/#{machine_type}"
+          @compute.set_instance_machine_type(@project, zone, instance, request)
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/google/requests/set_server_metadata.rb

@@ -0,0 +1,39 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def set_server_metadata(_instance, _zone, _fingerprint, _metadata_items = {})
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        # Set an instance metadata
+        #
+        # @param [String] instance Instance name (identity)
+        # @param [String] zone Name of zone
+        # @param [String] fingerprint The fingerprint of the last metadata.
+        #   Can be retrieved by reloading the compute object, and checking the
+        #   metadata fingerprint field.
+        #     instance.reload
+        #     fingerprint = instance.metadata['fingerprint']
+        # @param [Hash] metadata A new metadata object
+        #   Should have the following structure:
+        #   {'foo' => 'bar', 'baz'=>'foo'}
+        #
+        # @returns [::Google::Apis::ComputeV1::Operation] set operation
+        def set_server_metadata(instance, zone, fingerprint, metadata_items = [])
+          items = metadata_items.map { |item| ::Google::Apis::ComputeV1::Metadata::Item.new(item) }
+          @compute.set_instance_metadata(
+            @project, zone.split("/")[-1], instance,
+            ::Google::Apis::ComputeV1::Metadata.new(
+              :fingerprint => fingerprint, :items => items
+            )
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/google/requests/set_server_scheduling.rb

@@ -0,0 +1,24 @@
+module Fog
+  module Compute
+    class Google
+      class Mock
+        def set_server_scheduling(_identity, _zone, _on_host_maintenance, _automatic_restart, _preemptible)
+          # :no-coverage:
+          Fog::Mock.not_implemented
+          # :no-coverage:
+        end
+      end
+
+      class Real
+        def set_server_scheduling(identity, zone, on_host_maintenance: nil, automatic_restart: nil, preemptible: nil)
+          scheduling = ::Google::Apis::ComputeV1::Scheduling.new
+          scheduling.on_host_maintenance = on_host_maintenance unless on_host_maintenance.nil?
+          scheduling.automatic_restart = automatic_restart unless automatic_restart.nil?
+          scheduling.preemptible = preemptible unless preemptible.nil?
+          zone = zone.split("/")[-1]
+          @compute.set_instance_scheduling(@project, zone, identity, scheduling)
+        end
+      end
+    end
+  end
+end