plugin.yaml

plugins:
  # Name could be anything, this name is what appears on the beginning of operation
  # mappings.
  gcp_plugin:
    # Could be 'central_deployment_agent' or 'host_agent'.
    # If 'central_deployment_agent', this plugin will be executed on the
    # deployment dedicated agent, other wise it will be executed on the host agent.
    executor: central_deployment_agent

    # URL to archive containing the plugin or name of directory containing
    # the plugin if it is included in the the blueprint directory under the
    # "plugins" directory.
    source: https://github.com/szpotona/cloudify-gcp-plugin/archive/master.zip

node_types:
  cloudify.gcp.nodes.Instance:
    derived_from: cloudify.nodes.Compute
    properties:
      use_external_resource:
        description: >
          Indicate whether the resource exists and use existing (true) 
          or if Cloudify should create new resource (false).
        type: boolean
        default: false
      resource_id:
        description: >
          If "use_external_resource" is set to true, this field will be used as a name
          of existing instance that is referenced by this node.
        default: ''
      gcp_config:
        description: >
          A dictionary of values to pass to authenticate with the GCP API.
        default: {}
      image_id:
        description: >
          The ID of the image in your GCP account.
        type: string
        default: {}
      instance_type:
        description: >
          The instance's type. All available instance types can be found here: 
          https://cloud.google.com/compute/docs/machine-types
        type: string
        default: n1-standard-1
      instance_additional_settings:
        description: >
          Additional instance settings.
        default: {}
      name:
        description: >
          Optional instance name. By default it will be instance id.
        type: string
        default: ''
      zone:
        description: >
          Optional zone name. If not given, this instance will be deployed
          in default zone.
        type: string
        default: ''
    interfaces:
      cloudify.interfaces.lifecycle:
        start:
          implementation: gcp_plugin.gcp.compute.instance.create
          inputs:
            startup_script:
              default:
                  type: ''
                  string: ''
            external_ip:
              default: false
            instance_type:
              default: { get_property: [SELF, instance_type]}
            image_id:
              default: { get_property: [SELF, image_id]}
            name:
              default: { get_property: [SELF, name]}
            zone:
              default: { get_property: [SELF, zone]}
            scopes:
              default: ''
            user_data:
              default: ''
        delete:
          implementation: gcp_plugin.gcp.compute.instance.delete

  cloudify.gcp.nodes.InstanceGroup:
    derived_from: cloudify.nodes.Root
    properties:
      use_external_resource:
        description: >
          Indicate whether the resource exists and use existing (true)
          or if Cloudify should create new resource (false).
        type: boolean
        default: false
      resource_id:
        description: >
          If "use_external_resource" is set to true, this field will be used as a name
          of existing instance group that is referenced by this node.
        default: ''
      gcp_config:
        description: >
          A dictionary of values to pass to authenticate with the GCP API.
        default: {}
      name:
        description: >
          Optional instance name. By default it will be instance group id.
        type: string
        default: ''
      named_ports:
        description: >
          A list of named ports defined for this instance group, the expected
          format is: [{name: 'name', port: 1234}, ... ].
        default: []
    interfaces:
      cloudify.interfaces.lifecycle:
        create:
          implementation: gcp_plugin.gcp.compute.instance_group.create
          inputs:
            name:
              default: { get_property: [SELF, name]}
            named_ports:
              default: { get_property: [SELF, named_ports]}
        delete:
          implementation: gcp_plugin.gcp.compute.instance_group.delete

  cloudify.gcp.nodes.Volume:
    derived_from: cloudify.nodes.Volume
    properties:
      use_external_resource:
        description: >
          Indicate whether the resource exists or if Cloudify should create the resource.
        type: boolean
        default: false
      resource_id:
        description: >
          If "use_external_resource" is set to true, this field will be used as a name
          of existing volume that is referenced by this node.
        default: ''
      image:
        description: >
          The image of the Volume.
        default: ''
      gcp_config:
        description: >
          A dictionary of values to pass to authenticate with the Google Cloud Platform API.
        default: {}
      name:
        description: >
          Optional disk name. By default it will be disk id.
        type: string
        default: ''
      size:
        description: >
          Size of the Volume in GB.
        type: integer
        default: 10
    interfaces:
      cloudify.interfaces.lifecycle:
        create:
          implementation: gcp_plugin.gcp.compute.disk.create
          inputs:
            image:
              default: { get_property: [SELF, image] }
            name:
              default: { get_property: [SELF, name] }
            size:
              default: { get_property: [SELF, size] }
        delete:
          implementation: gcp_plugin.gcp.compute.disk.delete

  cloudify.gcp.nodes.Network:
    derived_from: cloudify.nodes.Network
    properties:
      use_external_resource:
        description: >
          Indicate whether the resource exists or if Cloudify should create the resource.
        type: boolean
        default: false
      resource_id:
        description: >
          If "use_external_resource" is set to true, this field will be used as a name
          of existing network that is referenced by this node.
        default: ''
      gcp_config:
        description: >
          A dictionary of values to pass to authenticate with the Google Cloud Platform API.
        default: {}
    interfaces:
      cloudify.interfaces.lifecycle:
        create:
          implementation: gcp_plugin.gcp.compute.network.create
          inputs:
            network:
              default: {}
        delete:
          implementation: gcp_plugin.gcp.compute.network.delete

  cloudify.gcp.nodes.FirewallRule:
    derived_from: cloudify.nodes.Root
    properties:
      use_external_resource:
        description: >
          Indicate whether the resource exists or if Cloudify should create the resource.
        type: boolean
        default: false
      resource_id:
        description: >
          If "use_external_resource" is set to true, this field will be used as a name
          of existing firewall rule that is referenced by this node.
        default: ''
      gcp_config:
        description: >
          A dictionary of values to pass to authenticate with the Google Cloud Platform API.
        default: {}
    interfaces:
      cloudify.interfaces.lifecycle:
        create:
          implementation: gcp_plugin.gcp.compute.firewall.create
          inputs:
            firewall_rule:
              default: {}
        delete:
          implementation: gcp_plugin.gcp.compute.firewall.delete

  cloudify.gcp.nodes.SecurityGroup:
    derived_from: cloudify.nodes.SecurityGroup
    properties:
      use_external_resource:
        description: >
          Indicate whether the resource exists or if Cloudify should create the resource.
        type: boolean
        default: false
      resource_id:
        description: >
          If "use_external_resource" is set to true, this field will be used as a name
          of existing security group that is referenced by this node.
        default: ''
      rules:
        description: >
          You need to pass in either source_tags list OR cidr_ip list,
          and then the following two: ip_protocol and port list OR target_tags list.
        default: []
      gcp_config:
        description: >
          A dictionary of values to pass to authenticate with the Google Cloud Platform API.
        default: {}
    interfaces:
      cloudify.interfaces.lifecycle:
        create: 
          implementation: gcp_plugin.gcp.compute.firewall.create_security_group
          inputs: 
            rules:
              default: { get_property: [SELF, rules] }
        delete:          
          implementation: gcp_plugin.gcp.compute.firewall.delete_security_group

  cloudify.gcp.nodes.KeyPair:
    derived_from: cloudify.nodes.Root
    properties:
      use_external_resource:
        description: >
          Indicate whether the resource exists or if Cloudify should create the resource.
        type: boolean
        default: false
      private_key_path:
        description: >
          The path where the key should be saved on the machine. If this is a bootstrap
          process, this refers to the local computer. If this will run on the manager,
          this will be saved on the manager.
        type: string
        default: ''
      public_key_path:
        description: >
          The path to read from existing public key.
        type: string
        default: ''
      gcp_config:
        description: >
          A dictionary of values to pass to authenticate with the Google Cloud Platform API.
        default: {}
      user:
        type: string
        default: ''
    interfaces:
      cloudify.interfaces.lifecycle:
        create:
          implementation: gcp_plugin.gcp.compute.keypair.create
          inputs:
            user: 
              default: { get_property: [SELF, user] }
            private_key_path: 
              default: { get_property: [SELF, private_key_path] }
            public_key_path:
              default: { get_property: [SELF, public_key_path] }
        delete:
          implementation: gcp_plugin.gcp.compute.keypair.delete
          inputs:
            user: 
              default: { get_property: [SELF, user] }
            private_key_path: 
              default: { get_property: [SELF, private_key_path] }

  cloudify.gcp.nodes.ExternalIP:
    derived_from: cloudify.nodes.VirtualIP
    properties:
      use_external_resource:
        description: >
          Indicate whether the resource exists or if Cloudify should create the resource.
          If set to true, this node will be static IP, otherwise ephemeral IP.
        type: boolean
        default: false
      ip_address:
        description: >
          Address of this external IP. This should be address of already existing,
          unattached static IP. It will be used only if "use_external_resource"
          is set to true.
        type: string
        default: ''
      gcp_config:
        description: >
          A dictionary of values to pass to authenticate with the GCP API.
        default: {}

  cloudify.gcp.nodes.StaticIP:
    derived_from: cloudify.nodes.VirtualIP
    properties:
      use_external_resource:
        description: >
          Indicate whether the resource exists or if Cloudify should create the resource.
          If set to true, this node will be already existing static IP address, otherwise
          it will be reserved static IP address.
        type: boolean
        default: false
      resource_id:
        description: >
          If "use_external_resource" is set to true, this field will be used as a name
          of existing static ip that is referenced by this node.
        default: ''
      gcp_config:
        description: >
          A dictionary of values to pass to authenticate with the GCP API.
        default: {}
      name:
        description: >
          Optional static ip name. By default it will be static ip id.
        type: string
        default: ''
    interfaces:
      cloudify.interfaces.lifecycle:
        create:
          implementation: gcp_plugin.gcp.compute.static_ip.create
          inputs:
            name:
              default: { get_property: [SELF, name]}
        delete:
          implementation: gcp_plugin.gcp.compute.static_ip.delete

  cloudify.gcp.nodes.Image:
    derived_from: cloudify.nodes.Root
    properties:
      use_external_resource:
        description: >
          Indicate whether the resource exists or if Cloudify should create the resource.
        type: boolean
        default: false
      resource_id:
        description: >
          If "use_external_resource" is set to true, this field will be used as a name
          of existing image that is referenced by this node.
        default: ''
      gcp_config:
        description: >
          A dictionary of values to pass to authenticate with the GCP API.
        default: {}
    interfaces:
      cloudify.interfaces.lifecycle:
        create:
          implementation: gcp_plugin.gcp.compute.image.create
          inputs:
            image_name:
              default: ''
            image_path:
              default: ''
        delete:
          implementation: gcp_plugin.gcp.compute.image.delete

  cloudify.gcp.nodes.HealthCheck:
    derived_from: cloudify.nodes.Root
    properties:
      use_external_resource:
        description: >
          Indicate whether the resource exists and use existing (true)
          or if Cloudify should create new resource (false).
        type: boolean
        default: false
      resource_id:
        description: >
          If "use_external_resource" is set to true, this field will be used as a name
          of existing health check that is referenced by this node.
        default: ''
      gcp_config:
        description: >
          A dictionary of values to pass to authenticate with the GCP API.
        default: {}
      name:
        description: >
          Optional health check name. By default it will be health check id.
        type: string
        default: ''
      health_check_type:
        description: >
          This field indicates if this health check is a HTTP or HTTPS based
          health check. Possible values are: 'http' and 'https'.
        type: string
        default: 'http'
      additional_settings:
        description: >
          Optional additional settings. Possible fields in dictionary are:
          port, request_path, timeout_sec, check_interval_sec,
          healthy_threshold, unhealthy_threshold.
        default: {}
    interfaces:
      cloudify.interfaces.lifecycle:
        create:
          implementation: gcp_plugin.gcp.compute.health_check.create
          inputs:
            name:
              default: { get_property: [SELF, name]}
            health_check_type:
              default: { get_property: [SELF, health_check_type]}
            additional_settings:
              default: { get_property: [SELF, additional_settings]}
        delete:
          implementation: gcp_plugin.gcp.compute.health_check.delete

  cloudify.gcp.nodes.BackendService:
    derived_from: cloudify.nodes.Root
    properties:
      use_external_resource:
        description: >
          Indicate whether the resource exists and use existing (true)
          or if Cloudify should create new resource (false).
        type: boolean
        default: false
      resource_id:
        description: >
          If "use_external_resource" is set to true, this field will be used as a name
          of existing backend service that is referenced by this node.
        default: ''
      gcp_config:
        description: >
          A dictionary of values to pass to authenticate with the GCP API.
        default: {}
      name:
        description: >
          Optional health check name. By default it will be backend service id.
        type: string
        default: ''
      health_check:
        description: >
          URL of a health check assigned to this backend service.
        type: string
        default: ''
      additional_settings:
        description: >
          Optional additional settings. Possible fields in dictionary are:
          port_name, protocol, timeout_sec.
        default: {}
    interfaces:
      cloudify.interfaces.lifecycle:
        create:
          implementation: gcp_plugin.gcp.compute.backend_service.create
          inputs:
            name:
              default: { get_property: [SELF, name]}
            health_check:
              default: { get_property: [SELF, health_check]}
            additional_settings:
              default: { get_property: [SELF, additional_settings]}
        delete:
          implementation: gcp_plugin.gcp.compute.backend_service.delete

  cloudify.gcp.nodes.UrlMap:
    derived_from: cloudify.nodes.Root
    properties:
      use_external_resource:
        description: >
          Indicate whether the resource exists and use existing (true)
          or if Cloudify should create new resource (false).
        type: boolean
        default: false
      resource_id:
        description: >
          If "use_external_resource" is set to true, this field will be used as a name
          of existing URL map that is referenced by this node.
        default: ''
      gcp_config:
        description: >
          A dictionary of values to pass to authenticate with the GCP API.
        default: {}
      name:
        description: >
          Optional health check name. By default it will be URL map id.
        type: string
        default: ''
      default_service:
        description: >
          URL of a backend service to which this URL map will redirect traffic by default.
        type: string
        default: ''
    interfaces:
      cloudify.interfaces.lifecycle:
        create:
          implementation: gcp_plugin.gcp.compute.url_map.create
          inputs:
            name:
              default: { get_property: [SELF, name]}
            default_service:
              default: { get_property: [SELF, default_service]}
        delete:
          implementation: gcp_plugin.gcp.compute.url_map.delete

  cloudify.gcp.nodes.TargetProxy:
    derived_from: cloudify.nodes.Root
    properties:
      use_external_resource:
        description: >
          Indicate whether the resource exists and use existing (true)
          or if Cloudify should create new resource (false).
        type: boolean
        default: false
      resource_id:
        description: >
          If "use_external_resource" is set to true, this field will be used as a name
          of existing target proxy that is referenced by this node.
        default: ''
      gcp_config:
        description: >
          A dictionary of values to pass to authenticate with the GCP API.
        default: {}
      name:
        description: >
          Optional target proxy name. By default it will be target proxy id.
        type: string
        default: ''
      target_proxy_type:
        description: >
          This field indicates if this target proxy is a HTTP or HTTPS based
          target proxy. Possible values are: 'http' and 'https'.
        type: string
        default: 'http'
      url_map:
        description: >
          URL of a URL map which specifies how traffic from this target proxy
          should be redirected.
        type: string
        default: ''
      ssl_certificate:
        description: >
          URL of a SSL certificate associated with this target proxy.
          Can and must be used only with https type proxy.
        type: string
        default: ''
    interfaces:
      cloudify.interfaces.lifecycle:
        create:
          implementation: gcp_plugin.gcp.compute.target_proxy.create
          inputs:
            name:
              default: { get_property: [SELF, name]}
            target_proxy_type:
              default: { get_property: [SELF, target_proxy_type]}
            url_map:
              default: { get_property: [SELF, url_map]}
            ssl_certificate:
              default: { get_property: [SELF, ssl_certificate]}
        delete:
          implementation: gcp_plugin.gcp.compute.target_proxy.delete

  cloudify.gcp.nodes.SslCertificate:
    derived_from: cloudify.nodes.Root
    properties:
      use_external_resource:
        description: >
          Indicate whether the resource exists and use existing (true)
          or if Cloudify should create new resource (false).
        type: boolean
        default: false
      resource_id:
        description: >
          If "use_external_resource" is set to true, this field will be used as a name
          of existing SSL certificate that is referenced by this node.
        default: ''
      gcp_config:
        description: >
          A dictionary of values to pass to authenticate with the GCP API.
        default: {}
      name:
        description: >
          Optional SSL certificate name. By default it will be SSL certificate id.
        type: string
        default: ''
      private_key:
        description: >
          Dictionary describing private key in PEM format used to generate this SSL certificate.
          Expected format is:
            type: text|file
            data: Private key in PEM format if text, otherwise path to a file with private key
        default: {}
      certificate:
        description: >
          Certificate (self-signed or obtained from CA) in PEM format.
          Expected format is:
            type: text|file
            data: Certificate in PEM format if text, otherwise path to a file with certificate
        default: {}
    interfaces:
      cloudify.interfaces.lifecycle:
        create:
          implementation: gcp_plugin.gcp.compute.ssl_certificate.create
          inputs:
            name:
              default: { get_property: [SELF, name]}
            private_key:
              default: { get_property: [SELF, private_key]}
            certificate:
              default: { get_property: [SELF, certificate]}
        delete:
          implementation: gcp_plugin.gcp.compute.ssl_certificate.delete

  cloudify.gcp.nodes.GlobalForwardingRule:
    derived_from: cloudify.nodes.Root
    properties:
      use_external_resource:
        description: >
          Indicate whether the resource exists and use existing (true)
          or if Cloudify should create new resource (false).
        type: boolean
        default: false
      resource_id:
        description: >
          If "use_external_resource" is set to true, this field will be used as a name
          of existing global forwarding rule that is referenced by this node.
        default: ''
      gcp_config:
        description: >
          A dictionary of values to pass to authenticate with the GCP API.
        default: {}
      name:
        description: >
          Optional global forwarding rule name. By default it will be
          global forwarding rule id.
        type: string
        default: ''
      target_proxy:
        description: >
          URL of a target proxy (http or https) that will receive traffic
          coming from specified IP address.
        type: string
        default: ''
      port_range:
        description: >
          Port number used by this forwarding rule. If packets are redirected to
          HTTP proxy, then possible values are 80 and 8080, in case of HTTPS proxy
          the only accepted value is 443.
        type: string
        default: '80'
      ip_address:
        description: >
          IP address associated with this forwarding rule. This address
          should be reserved earlier.
        type: string
        default: ''
    interfaces:
      cloudify.interfaces.lifecycle:
        create:
          implementation: gcp_plugin.gcp.compute.forwarding_rule.create
          inputs:
            name:
              default: { get_property: [SELF, name]}
            target_proxy:
              default: { get_property: [SELF, target_proxy]}
            port_range:
              default: { get_property: [SELF, port_range]}
            ip_address:
              default: { get_property: [SELF, ip_address]}
        delete:
          implementation: gcp_plugin.gcp.compute.forwarding_rule.delete

relationships:

  cloudify.gcp.relationships.contained_in_compute:
    derived_from: cloudify.relationships.contained_in
    source_interfaces:
      cloudify.interfaces.relationship_lifecycle:
        preconfigure:
          implementation: gcp_plugin.gcp.compute.instance.contained_in

  cloudify.gcp.relationships.instance_connected_to_security_group:
    derived_from: cloudify.relationships.connected_to
    source_interfaces:
      cloudify.interfaces.relationship_lifecycle:
        establish:
          implementation: gcp_plugin.gcp.compute.instance.add_instance_tag
          inputs:
            instance_name: 
              default: { get_attribute: [SOURCE, gcp_name] }
            tag:
              default: { get_attribute: [TARGET, targetTags] }
        unlink:
          implementation: gcp_plugin.gcp.compute.instance.remove_instance_tag
          inputs:
            instance_name: 
              default: { get_attribute: [SOURCE, gcp_name] }
            tag:
              default: { get_attribute: [TARGET, targetTags] }

  cloudify.gcp.relationships.instance_connected_to_ip:
    derived_from: cloudify.relationships.connected_to
    source_interfaces:
      cloudify.interfaces.relationship_lifecycle:
        establish:
          implementation: gcp_plugin.gcp.compute.instance.add_external_ip
          inputs:
            instance_name: 
              default: { get_attribute: [SOURCE, gcp_name] }
        unlink:
          implementation: gcp_plugin.gcp.compute.instance.remove_external_ip
          inputs:
            instance_name: 
              default: { get_attribute: [SOURCE, gcp_name] }

  cloudify.gcp.relationships.instance_connected_to_keypair:
    derived_from: cloudify.relationships.connected_to
    target_interfaces:
      cloudify.interfaces.relationship_lifecycle:
        preconfigure:
          implementation: gcp_plugin.gcp.compute.instance.add_ssh_key
          inputs:
            instance_name:
              default: { get_attribute: [SOURCE, gcp_name] }

  cloudify.gcp.relationships.file_system_contained_in_compute:
    derived_from: cloudify.relationships.contained_in
    target_interfaces:
      cloudify.interfaces.relationship_lifecycle:
        preconfigure:
          implementation: gcp_plugin.gcp.compute.disk.add_boot_disk

  cloudify.gcp.relationships.instance_connected_to_disk:
    derived_from: cloudify.relationships.connected_to
    source_interfaces:
      cloudify.interfaces.relationship_lifecycle:
        establish:
          implementation: gcp_plugin.gcp.compute.instance.attach_disk
          inputs:
            instance_name: 
              default: { get_attribute: [TARGET, gcp_name] }
            disk: 
              default: { get_attribute: [SOURCE, gcp_disk] }
        unlink:
          implementation: gcp_plugin.gcp.compute.instance.detach_disk
          inputs:
            instance_name: 
              default: { get_property: [TARGET, gcp_name] }
            disk_name: 
              default: { get_attribute: [SOURCE, gcp_name] }

  cloudify.gcp.relationships.instance_connected_to_instance_group:
    derived_from: cloudify.relationships.connected_to
    source_interfaces:
      cloudify.interfaces.relationship_lifecycle:
        establish:
          implementation: gcp_plugin.gcp.compute.instance_group.add_to_instance_group
          inputs:
            instance_group_name:
              default: { get_attribute: [TARGET, gcp_name] }
            instance_name:
              default: { get_attribute: [SOURCE, gcp_name] }
        unlink:
          implementation: gcp_plugin.gcp.compute.instance_group.remove_from_instance_group
          inputs:
            instance_group_name:
              default: { get_attribute: [TARGET, gcp_name] }
            instance_name:
              default: { get_attribute: [SOURCE, gcp_name] }

  cloudify.gcp.relationships.uses_as_backend:
    derived_from: cloudify.relationships.connected_to
    source_interfaces:
      cloudify.interfaces.relationship_lifecycle:
        establish:
          implementation: gcp_plugin.gcp.compute.backend_service.add_backend
          inputs:
            backend_service_name:
              default: { get_attribute: [SOURCE, gcp_name] }
            group_self_url:
              default: { get_attribute: [TARGET, self_url] }
        unlink:
          implementation: gcp_plugin.gcp.compute.backend_service.remove_backend
          inputs:
            backend_service_name:
              default: { get_attribute: [SOURCE, gcp_name] }
            group_self_url:
              default: { get_attribute: [TARGET, self_url] }