vcloud-without-agent-blueprint.yaml

tosca_definitions_version: cloudify_dsl_1_0

imports:
    - http://www.getcloudify.org/spec/cloudify/3.3m3/types.yaml
    - https://raw.githubusercontent.com/cloudify-cosmo/tosca-vcloud-plugin/master/plugin.yaml
    - http://www.getcloudify.org/spec/fabric-plugin/1.3m3/plugin.yaml
    - types/agentless-nodecellar.yaml

inputs:
    vcloud_username:
        type: string
        description: >
            User login for vcloud air

    vcloud_password:
        type: string
        default: ''
        description: >
            User password for vcloud air - for login by name + password

    vcloud_token:
        type: string
        default: ''
        description: >
            User token for vcloud air - for login by name + token

    vcloud_url:
        type: string
        description: >
            Vcloud url

    vcloud_service:
        type: string
        description: >
            Vcloud service

    vcloud_service_type:
        type: string
        default: 'subscription'
        description: >
            Type of service: subscription, ondemand, vcd, private

    vcloud_instance:
        type: string
        default: ''
        description: >
            Only required for ondemand service type, instance uuid

    vcloud_api_version:
        type: string
        default: '5.6'
        description: >
            Version of api, for now 5.6

    nodejs_ssh:
        type: string
        default: 22
        description: >
            Ssh port for nodejs host

    mongo_ssh:
        type: string
        default: 23
        description: >
            Ssh port for mongodb host

    nodejs_http:
        type: string
        default: 8080
        description: >
            Http port for nodejs host

    vcloud_org_url:
        type: string
        default: ''
        description: >
            Only required if using token based login on a private vcloud
            director. This can be obtained by following the vcloud API
            example docs. If you are unsure of how to obtain this, you will
            need to use password based login.

    vcloud_org:
        type: string
        description: >
            Organization uuid

    vcloud_vdc:
        type: string
        description: >
            Virtual data center name

    catalog:
        type: string
        description: >
            Name of catalog, can be 'Public Catalog'

    template:
        type: string
        description: >
            Name of template from catalog,
            can be 'Ubuntu Server 12.04 LTS (amd64 20150127)'

    server_cpu:
        type: string
        default: 2
        description: >
            Count cpu on nodes

    server_memory:
        type: string
        default: 4096
        description: >
            Amount memmory on nodes

    network_use_existing:
        type: boolean
        default: false
        description: >
            Use existed network

    common_network_name:
        type: string
        description: >
            Name common network taht can be used for nodes

    port_ip_allocation_mode:
        type: string
        default: pool
        description: >
            Ip allocation type for case when you doesn't set public ip
            for nodes and want auto allocate ip

    nodejs_ip_address:
        type: string
        default: ''
        description: >
            For 'ondemand' service type, the value of
            nodejs_ip_address can be empty

    mongo_ip_address:
        type: string
        default: ''
        description: >
            For 'ondemand' service type, the value of
            mongo_ip_address can be empty

    common_network_public_nat_use_existing:
        type: boolean
        default: false
        description: >
            Use already existed nat rules, only for case when you
            doesn't want to change nat rules

    edge_gateway:
        type: string
        default: gateway
        description: >
            For 'ondemand' service type, the value of edge_gateway
            is always 'gateway'

    servers_user:
        default: ubuntu
        type: string
        description: >
            Default admin user in os template

    private_key_path:
        default: ~/.ssh/cloudify-agent-kp.pem
        type: string
        description: >
            Please upload key to manager server before use key

    user_public_key:
        type: string
        default: ''
        description: >
            Public key

    resources_prefix:
        type: string
        default: ''
        description: >
            Prefix for nodes

node_types:

    # base server type for installation without agent
    agentless-nodecellar.nodes.ParentTypeServer:
        derived_from: cloudify.vcloud.nodes.Server
        properties:
            install_agent:
                default: false

    vcloud_configuration:
        derived_from: cloudify.nodes.Root
        properties:
            vcloud_config: {}

node_templates:

    vcloud_configuration:
        type: vcloud_configuration
        properties:
            vcloud_config:
                username: { get_input: vcloud_username }
                password: { get_input: vcloud_password }
                token: { get_input: vcloud_token }
                url: { get_input: vcloud_url }
                service: { get_input: vcloud_service }
                org: { get_input: vcloud_org }
                vdc: { get_input: vcloud_vdc }
                service_type: { get_input: vcloud_service_type }
                instance: { get_input: vcloud_instance }
                api_version: { get_input: vcloud_api_version }
                org_url: { get_input: vcloud_org_url }
                edge_gateway: { get_input: edge_gateway }

    nodejs_host:
        type: agentless-nodecellar.nodes.ParentTypeServer
        properties:
            server:
                catalog: { get_input: catalog }
                template: { get_input: template }
                guest_customization:
                    public_keys:
                        - { get_property: [common_keypair, public_key] }
                hardware:
                    cpu: { get_input: server_cpu }
                    memory: { get_input: server_memory }
            management_network: { get_input: common_network_name }
            vcloud_config: { get_property: [vcloud_configuration, vcloud_config] }
        relationships:
            - target: nodejs_host_nat
              type: cloudify.vcloud.server_connected_to_public_nat
            - target: node_security_group
              type: cloudify.vcloud.server_connected_to_security_group

    mongod_host:
        type: agentless-nodecellar.nodes.ParentTypeServer
        properties:
            server:
                catalog: { get_input: catalog }
                template: { get_input: template }
                guest_customization:
                    public_keys:
                        - { get_property: [common_keypair, public_key] }
                hardware:
                    cpu: { get_input: server_cpu }
                    memory: { get_input: server_memory }
            management_network: { get_input: common_network_name }
            vcloud_config: { get_property: [vcloud_configuration, vcloud_config] }
        relationships:
            - target: mongo_server_nat
              type: cloudify.vcloud.server_connected_to_public_nat
            - target: node_security_group
              type: cloudify.vcloud.server_connected_to_security_group

    common_network:
        type: cloudify.vcloud.nodes.Network
        properties:
            use_external_resource: { get_input: network_use_existing }
            resource_id: { get_input: common_network_name }
            network:
                name: { get_input: common_network_name }
                edge_gateway: { get_input: edge_gateway }
                static_range: 10.67.80.129-10.67.80.254
                netmask: 255.255.255.0
                gateway_ip: 10.67.80.1
                dns:
                    - 10.67.80.1
                    - 8.8.8.8
                dhcp:
                    dhcp_range: 10.67.80.2-10.67.80.128
            vcloud_config: { get_property: [vcloud_configuration, vcloud_config] }
        relationships:
            - target: common_network_nat
              type: cloudify.vcloud.net_connected_to_public_nat

    common_network_nat:
        type: cloudify.vcloud.nodes.PublicNAT
        properties:
            use_external_resource: { get_input: common_network_public_nat_use_existing }
            nat:
                edge_gateway: { get_input: edge_gateway }
                public_ip: { get_input: nodejs_ip_address }
            rules:
                - type: SNAT
            vcloud_config: { get_property: [vcloud_configuration, vcloud_config] }

    nodejs_host_nat:
        type: cloudify.vcloud.nodes.PublicNAT
        properties:
            nat:
                edge_gateway: { get_input: edge_gateway }
                public_ip: { get_input: nodejs_ip_address }
            rules:
             - type: DNAT
               protocol: tcp
               original_port: { get_input: nodejs_http }
               translated_port: 8080
             - type: DNAT
               protocol: tcp
               original_port: { get_input: nodejs_ssh }
               translated_port: 22
            vcloud_config: { get_property: [vcloud_configuration, vcloud_config] }

    mongo_server_nat:
        type: cloudify.vcloud.nodes.PublicNAT
        properties:
            nat:
                edge_gateway: { get_input: edge_gateway }
                public_ip: { get_input: mongo_ip_address }
            rules:
             - type: DNAT
               protocol: tcp
               original_port: { get_input: mongo_ssh }
               translated_port: 22
            vcloud_config: { get_property: [vcloud_configuration, vcloud_config] }

    node_security_group:
        type: cloudify.vcloud.nodes.SecurityGroup
        properties:
            security_group:
                name: nodevcloud_security_group
                edge_gateway: { get_input: edge_gateway }
            rules:
                - source: any
                  destination: internal
                  destination_port: { get_input: nodejs_ssh }
                  action: allow
                  description: >
                        ssh to node_js
                  protocol: TCP
                - source: any
                  destination: internal
                  destination_port: { get_input: mongo_ssh }
                  action: allow
                  description: >
                        ssh to mongo
                  protocol: TCP
                - source: internal
                  destination: internal
                  destination_port: 27017
                  action: allow
                  description: >
                        mongo <-> nodejs connection
                  protocol: TCP
                - source: external
                  destination: internal
                  destination_port: 8080
                  action: allow
                  description: >
                        http to nodejs
                  protocol: TCP
                - source: internal
                  destination: any
                  action: allow
                  description: >
                         backward network connection for host updates
                  protocol: any
                - source: external
                  destination: internal
                  action: allow
                  description: >
                         Allow ping
                  protocol: ICMP
            vcloud_config: { get_property: [vcloud_configuration, vcloud_config] }

    common_keypair:
        type: cloudify.vcloud.nodes.KeyPair
        properties:
            private_key_path: { get_input: private_key_path }
            public_key:
                key: { get_input: user_public_key }
                user: { get_input: servers_user }

    nodejs:
        type: agentless-nodecellar.nodes.NodeJSServer
        relationships:
          - target: nodejs_host
            type: cloudify.relationships.contained_in
        interfaces:
            cloudify.interfaces.lifecycle:
                start:
                    inputs:
                        fabric_env:
                            user: { get_input: servers_user }
                            key_filename: { get_input: private_key_path }
                            host_string: { get_attribute: [nodejs_host_nat, public_ip] }
                            port: { get_input: nodejs_ssh }

    mongod:
        type: agentless-nodecellar.nodes.MongoDatabase
        relationships:
          - target: mongod_host
            type: cloudify.relationships.contained_in
        interfaces:
            cloudify.interfaces.lifecycle:
                start:
                    inputs:
                        fabric_env:
                            user: { get_input: servers_user }
                            key_filename: { get_input: private_key_path }
                            host_string: { get_attribute: [mongo_server_nat, public_ip] }
                            port: { get_input: mongo_ssh }

    nodecellar:
        type: agentless-nodecellar.nodes.nodecellar
        interfaces:
            cloudify.interfaces.lifecycle:
                start:
                    inputs:
                        task_properties:
                            config:
                                mongo: { get_attribute: [mongod_host, ip] }
                        fabric_env:
                            user: { get_input: servers_user }
                            key_filename: { get_input: private_key_path }
                            host_string: { get_attribute: [nodejs_host_nat, public_ip] }
                            port: { get_input: nodejs_ssh }
        relationships:
          - type: cloudify.relationships.contained_in
            target: nodejs
          - type: cloudify.relationships.connected_to
            target: mongod

outputs:
    nodejs_ip:
        value: { get_attribute: [nodejs_host_nat, public_ip] }