Difference between revisions of "GPII Services Configuration"

From wiki.gpii
Jump to: navigation, search
(Deploying GPII Architecture Components)
Line 1: Line 1:
 
= Description =
 
= Description =
  
The GPII architecture is designed to be flexible and highly configurable. It consists of many components that can be configured without modifying their implementation, or swapped out entirely for other implementations. This configuration is done by creating new or editing existing JSON configuration files that describe various components for specific GPII deployment types.
+
The GPII/Kettle architecture is designed to be flexible and highly configurable. It consists of many components that can be configured without modifying their implementation, or swapped out entirely for other implementations. This configuration is done by creating new or editing existing JSON configuration files that describe various components for specific GPII/Kettle deployment types.
  
 
With the help of these configuration files, developers can configure which components are deployed and with what settings. Examples of such configurations include:
 
With the help of these configuration files, developers can configure which components are deployed and with what settings. Examples of such configurations include:
Line 17: Line 17:
  
  
The source code for the core framework and all platform independent components can be found here: [https://github.com/GPII/universal GPII Universal]
+
The source code for the core framework and all platform independent components can be found here: [https://github.com/GPII/universal GPII Universal], [https://github.com/fluid-infusion/kettle Kettle]
  
 
All platform specific components can be found in the following repositories:
 
All platform specific components can be found in the following repositories:
Line 28: Line 28:
 
----
 
----
  
== GPII Server ==
+
== Kettle Server ==
  
The <code>gpii.server</code> component is one of the building blocks of the GPII framework you are deploying. It represents a single instance of a [http://nodejs.org/ Node.js] http server.
+
The <code>kettle.server</code> component is one of the building blocks of the Kettle framework you are deploying. It represents a single instance of a [http://nodejs.org/ Node.js] http server.
  
It serves as a container for one or more <code>gpii.app</code>s (see below). Developers have the option of deploying a number of GPII servers that themselves contain one or more GPII apps.
+
It serves as a container for one or more <code>kettle.app</code>s (see below). Developers have the option of deploying a number of Kettle servers that themselves contain one or more Kettle apps.
  
The source code for the <code>gpii.server</code> can be found here: [https://github.com/GPII/universal/blob/master/gpii/node_modules/gpiiFramework/server.js gpii.server]
+
The source code for the <code>kettle.server</code> can be found here: [https://github.com/fluid-project/kettle/blob/master/lib/server.js kettle.server]
  
 
----
 
----
 
----
 
----
  
== GPII App ==
+
== Kettle App ==
  
The <code>gpii.app</code> component is a component that represents a single purpose app deployed within a particular <code>gpii.server</code>. The majority of the existing components within the GPII architecture that support the HTTP API (such as the Flow Manager, Device Reporter, Match Maker, Preferences Server, Solutions Registry, etc) are, in fact, <code>gpii.app</code>s themselves.
+
The <code>kettle.app</code> component is a component that represents a single purpose app deployed within a particular <code>kettle.server</code>. The majority of the existing components within the Kettle architecture that support the HTTP API (such as the Flow Manager, Device Reporter, Match Maker, Preferences Server, Solutions Registry, etc) are, in fact, <code>kettle.app</code>s themselves.
  
The source code for the <code>gpii.app</code> can be found here: [https://github.com/GPII/universal/blob/master/gpii/node_modules/gpiiFramework/app.js gpii.app]
+
The source code for the <code>kettle.app</code> can be found here: [https://github.com/fluid-project/kettle/blob/master/lib/app.js kettle.app]
  
To configure a specific GPII deployment, you will be setting up the appropriate GPII servers and GPII apps required for the deployment.
+
To configure a specific Kettle deployment, you will be setting up the appropriate Kettle servers and Kettle apps required for the deployment.
  
 
----
 
----
Line 55: Line 55:
 
There are several conventions in regards to where your configuration file should go:
 
There are several conventions in regards to where your configuration file should go:
  
* If you are creating configuration for multiple apps, consider putting it in <code>universal/gpii/configs</code> if all your GPII apps are defined in a [https://github.com/GPII/universal GPII Universal] repository. If one or more apps are defined in a platform specific repository, your configuration files should go into a top level <code>configs</code> directory (Note: you might have to create it) within the appropriate platform specific repository.
+
* If you are creating configuration for multiple apps, consider putting it in <code>universal/gpii/configs</code> if all your Kettle apps are defined in a [https://github.com/GPII/universal GPII Universal] repository. If one or more apps are defined in a platform specific repository, your configuration files should go into a top level <code>configs</code> directory (Note: you might have to create it) within the appropriate platform specific repository.
* If you are creating configuration for a single <code>gpii.app</code>, you need to save it in the <code>configs</code> directory that corresponds to the location of that GPII app. Currently, all GPII apps are located in <code>universal/gpii/node_modules</code> (e.g. Preferences Server, Solutions Registry, etc). Thus, the config file should be located at this path: <code>universal/gpii/node_modules/{some gpii app}/configs</code>.
+
* If you are creating configuration for a single <code>kettle.app</code>, you need to save it in the <code>configs</code> directory that corresponds to the location of that Kettle app. Currently, all Kettle apps are located in <code>universal/gpii/node_modules</code> (e.g. Preferences Server, Solutions Registry, etc). Thus, the config file should be located at this path: <code>universal/gpii/node_modules/{some kettle app}/configs</code>.
  
 
==== Basic configuration ====
 
==== Basic configuration ====
A single <code>gpii.server</code> and no <code>gpii.app</code>s.
+
A single <code>kettle.server</code> and no <code>kettle.app</code>s.
  
 
This configuration will deploy a single empty server container:
 
This configuration will deploy a single empty server container:
Line 68: Line 68:
 
         "gradeNames": ["autoInit", "fluid.littleComponent"],
 
         "gradeNames": ["autoInit", "fluid.littleComponent"],
 
         "components": {                // List of components to be deployed.
 
         "components": {                // List of components to be deployed.
             "gpii server component": { // The name of the server component.
+
             "kettle server component": { // The name of the server component.
                 "type": "gpii.server"  // The type of the server component.
+
                 "type": "kettle.server"  // The type of the server component.
 
             }
 
             }
 
         }
 
         }
Line 77: Line 77:
  
 
==== Multiple servers ====
 
==== Multiple servers ====
Two <code>gpii.server</code>s with no <code>gpii.app</code>s.
+
Two <code>kettle.server</code>s with no <code>kettle.app</code>s.
  
 
This configuration will deploy two empty server containers.
 
This configuration will deploy two empty server containers.
Line 87: Line 87:
 
         "components": {
 
         "components": {
 
             "server one": {
 
             "server one": {
                 "type": "gpii.server"
+
                 "type": "kettle.server"
 
             },
 
             },
 
             "server two": {
 
             "server two": {
                 "type": "gpii.server"
+
                 "type": "kettle.server"
 
             }
 
             }
 
         }
 
         }
Line 98: Line 98:
  
 
==== One server with one app ====
 
==== One server with one app ====
A single <code>gpii.server</code> that contains a <code>gpii.app</code>.
+
A single <code>kettle.server</code> that contains a <code>kettle.app</code>.
  
 
This configuration will deploy a single server with an empty app that does nothing.
 
This configuration will deploy a single server with an empty app that does nothing.
Line 108: Line 108:
 
         "components": {
 
         "components": {
 
             "server": {
 
             "server": {
                 "type": "gpii.server",
+
                 "type": "kettle.server",
 
                 "components": {
 
                 "components": {
                     "gpii app component": {
+
                     "kettle app component": {
                         "type": "gpii.app" // For example: "gpii.preferencesServer"
+
                         "type": "kettle.app" // For example: "gpii.preferencesServer"
 
                     }
 
                     }
 
                 }
 
                 }
Line 121: Line 121:
  
 
==== One server with several apps ====
 
==== One server with several apps ====
A single <code>gpii.server</code> that contains two <code>gpii.app</code>s.
+
A single <code>kettle.server</code> that contains two <code>kettle.app</code>s.
  
 
This configuration will deploy a single server with two empty apps that do nothing.
 
This configuration will deploy a single server with two empty apps that do nothing.
Line 131: Line 131:
 
         "components": {
 
         "components": {
 
             "server": {
 
             "server": {
                 "type": "gpii.server",
+
                 "type": "kettle.server",
 
                 "components": {
 
                 "components": {
                     "gpii app component": {
+
                     "kettle app component": {
                         "type": "gpii.app"
+
                         "type": "kettle.app"
 
                     },
 
                     },
 
                     "preferencesServer": {
 
                     "preferencesServer": {
Line 155: Line 155:
 
         "gradeNames": ["autoInit", "fluid.littleComponent"],
 
         "gradeNames": ["autoInit", "fluid.littleComponent"],
 
         "components": {
 
         "components": {
             "gpii server component": {
+
             "kettle server component": {
                 "type": "gpii.server",
+
                 "type": "kettle.server",
 
                 "options": {
 
                 "options": {
                     // GPII Server options
+
                     // Kettle Server options
 
                     "logging": true,
 
                     "logging": true,
 
                     "port": 80
 
                     "port": 80
Line 175: Line 175:
 
         "components": {
 
         "components": {
 
             "server": {
 
             "server": {
                 "type": "gpii.server",
+
                 "type": "kettle.server",
 
                 "components": {
 
                 "components": {
                     "gpii app component": {
+
                     "kettle app component": {
                         "type": "gpii.app",
+
                         "type": "kettle.app",
 
                         "options": {
 
                         "options": {
                             "some option": "some option value" // GPII App option
+
                             "some option": "some option value" // Kettle App option
 
                         }
 
                         }
 
                     }
 
                     }
Line 201: Line 201:
 
         "components": {
 
         "components": {
 
             "server": {
 
             "server": {
                 "type": "gpii.server"
+
                 "type": "kettle.server"
 
             }
 
             }
 
         }
 
         }
Line 212: Line 212:
  
 
==== Demands (Advanced) ====
 
==== Demands (Advanced) ====
There is another indirect way of configuring all components in the deployment that are not necessarily a <code>gpii.server</code> or a <code>gpii.app</code>. It is done via specific configuration blocks called "demands".
+
There is another indirect way of configuring all components in the deployment that are not necessarily a <code>kettle.server</code> or a <code>kettle.app</code>. It is done via specific configuration blocks called "demands".
  
 
This configuration will deploy a server and also set a "some option" setting set to "some option value" for a "component name we want to configure" when it is created as part of "your configuration name" configuration.
 
This configuration will deploy a server and also set a "some option" setting set to "some option value" for a "component name we want to configure" when it is created as part of "your configuration name" configuration.
Line 222: Line 222:
 
         "components": {
 
         "components": {
 
             "server": {
 
             "server": {
                 "type": "gpii.server"
+
                 "type": "kettle.server"
 
             }
 
             }
 
         }
 
         }
Line 244: Line 244:
 
= Examples of Existing Configuration Files  =
 
= Examples of Existing Configuration Files  =
  
Below are examples of some of the existing configuration files that are currently used to deploy single GPII apps or all of GPII architecture.
+
Below are examples of some of the existing configuration files that are currently used to deploy single Kettle apps or all of GPII architecture.
  
 
==== [https://github.com/GPII/universal/blob/master/gpii/node_modules/preferencesServer/configs/production.json Preferences Server (Production)] ====
 
==== [https://github.com/GPII/universal/blob/master/gpii/node_modules/preferencesServer/configs/production.json Preferences Server (Production)] ====
Line 257: Line 257:
 
         "components": {
 
         "components": {
 
             "server": {
 
             "server": {
                 "type": "gpii.server",
+
                 "type": "kettle.server",
 
                 "options": {
 
                 "options": {
 
                     "logging": false,
 
                     "logging": false,
Line 276: Line 276:
 
         "contextNames": "gpii.preferencesServer",
 
         "contextNames": "gpii.preferencesServer",
 
         "demandSpec": {
 
         "demandSpec": {
             "funcName": "gpii.dataSource.CouchDB" // (*)
+
             "funcName": "kettle.dataSource.CouchDB" // (*)
 
         }
 
         }
 
     }],
 
     }],
Line 296: Line 296:
 
         "components": {
 
         "components": {
 
             "server": {
 
             "server": {
                 "type": "gpii.server",
+
                 "type": "kettle.server",
 
                 "options": {
 
                 "options": {
 
                     "logging": true,
 
                     "logging": true,
Line 312: Line 312:
 
     },
 
     },
 
     "demands": [{
 
     "demands": [{
         "demandingName": "gpii.urlExpander",
+
         "demandingName": "kettle.urlExpander",
 
         "contextNames": "gpii.preferencesServer",
 
         "contextNames": "gpii.preferencesServer",
 
         "demandSpec": {
 
         "demandSpec": {
             "funcName": "gpii.urlExpander.development"
+
             "funcName": "kettle.urlExpander.development"
 
         }
 
         }
 
     }, {
 
     }, {
Line 321: Line 321:
 
         "contextNames": "gpii.preferencesServer",
 
         "contextNames": "gpii.preferencesServer",
 
         "demandSpec": {
 
         "demandSpec": {
             "funcName": "gpii.dataSource.URL" // (*)
+
             "funcName": "kettle.dataSource.URL" // (*)
 
         }
 
         }
 
     }],
 
     }],
Line 337: Line 337:
 
{
 
{
 
     "demands": [{
 
     "demands": [{
         "demandingName": "gpii.requests.request.handler",
+
         "demandingName": "kettle.requests.request.handler",
 
         "contextNames": "userGet",
 
         "contextNames": "userGet",
 
         "demandSpec": {
 
         "demandSpec": {
Line 343: Line 343:
 
                 "invokers": {
 
                 "invokers": {
 
                     "handle": {
 
                     "handle": {
                         "funcName": "gpii.requests.request.handler.userGet",
+
                         "funcName": "kettle.requests.request.handler.userGet",
 
                         "args": ["{requestProxy}", "{request}.req.params.token", "{preferencesServer}.userSource"]
 
                         "args": ["{requestProxy}", "{request}.req.params.token", "{preferencesServer}.userSource"]
 
                     }
 
                     }
Line 350: Line 350:
 
         }
 
         }
 
     }, {
 
     }, {
         "demandingName": "gpii.requests.request.handler",
+
         "demandingName": "kettle.requests.request.handler",
 
         "contextNames": "userPost",
 
         "contextNames": "userPost",
 
         "demandSpec": {
 
         "demandSpec": {
Line 356: Line 356:
 
                 "invokers": {
 
                 "invokers": {
 
                     "handle": {
 
                     "handle": {
                         "funcName": "gpii.requests.request.handler.userPost",
+
                         "funcName": "kettle.requests.request.handler.userPost",
 
                         "args": ["{requestProxy}", "{request}.req", "{preferencesServer}.userSource"]
 
                         "args": ["{requestProxy}", "{request}.req", "{preferencesServer}.userSource"]
 
                     }
 
                     }
Line 372: Line 372:
 
             }
 
             }
 
         }
 
         }
     }]
+
     }],
 +
    "modules": [
 +
        "preferencesServer"
 +
    ]
 
}
 
}
 
</pre>
 
</pre>
Line 387: Line 390:
 
         "components": {
 
         "components": {
 
             "server": {
 
             "server": {
                 "type": "gpii.server",
+
                 "type": "kettle.server",
 
                 "options": {
 
                 "options": {
 
                     "logging": true,
 
                     "logging": true,
Line 404: Line 407:
 
     },
 
     },
 
     "demands": [{
 
     "demands": [{
         "demandingName": "gpii.urlExpander",
+
         "demandingName": "kettle.urlExpander",
 
         "contextNames": "gpii.matchMaker",
 
         "contextNames": "gpii.matchMaker",
 
         "demandSpec": {
 
         "demandSpec": {
             "funcName": "gpii.urlExpander.development"
+
             "funcName": "kettle.urlExpander.development"
 
         }
 
         }
 
     }, {
 
     }, {
Line 433: Line 436:
 
         "components": {
 
         "components": {
 
             "server": {
 
             "server": {
                 "type": "gpii.server",
+
                 "type": "kettle.server",
 
                 "options": {
 
                 "options": {
 
                     "logging": true,
 
                     "logging": true,

Revision as of 19:12, 13 August 2013

Description

The GPII/Kettle architecture is designed to be flexible and highly configurable. It consists of many components that can be configured without modifying their implementation, or swapped out entirely for other implementations. This configuration is done by creating new or editing existing JSON configuration files that describe various components for specific GPII/Kettle deployment types.

With the help of these configuration files, developers can configure which components are deployed and with what settings. Examples of such configurations include:

  • Configuring URL locations for GPII resources
  • Configuring Match Maker strategies
  • Registering events and event listeners within various workflows

This page contains all the necessary information on how to configure various components (Flow Manager, Match Maker, Device Reporter, etc) within the GPII framework.



Getting Started

In order to proceed with the configuration and deployment tasks, please make sure that your development environment is set up: Setting Up Your Development Environment.


The source code for the core framework and all platform independent components can be found here: GPII Universal, Kettle

All platform specific components can be found in the following repositories:



Kettle Server

The kettle.server component is one of the building blocks of the Kettle framework you are deploying. It represents a single instance of a Node.js http server.

It serves as a container for one or more kettle.apps (see below). Developers have the option of deploying a number of Kettle servers that themselves contain one or more Kettle apps.

The source code for the kettle.server can be found here: kettle.server



Kettle App

The kettle.app component is a component that represents a single purpose app deployed within a particular kettle.server. The majority of the existing components within the Kettle architecture that support the HTTP API (such as the Flow Manager, Device Reporter, Match Maker, Preferences Server, Solutions Registry, etc) are, in fact, kettle.apps themselves.

The source code for the kettle.app can be found here: kettle.app

To configure a specific Kettle deployment, you will be setting up the appropriate Kettle servers and Kettle apps required for the deployment.




Creating a Configuration File

There are several conventions in regards to where your configuration file should go:

  • If you are creating configuration for multiple apps, consider putting it in universal/gpii/configs if all your Kettle apps are defined in a GPII Universal repository. If one or more apps are defined in a platform specific repository, your configuration files should go into a top level configs directory (Note: you might have to create it) within the appropriate platform specific repository.
  • If you are creating configuration for a single kettle.app, you need to save it in the configs directory that corresponds to the location of that Kettle app. Currently, all Kettle apps are located in universal/gpii/node_modules (e.g. Preferences Server, Solutions Registry, etc). Thus, the config file should be located at this path: universal/gpii/node_modules/{some kettle app}/configs.

Basic configuration

A single kettle.server and no kettle.apps.

This configuration will deploy a single empty server container:

{
    "typeName": "your configuration name",
    "options": {
        "gradeNames": ["autoInit", "fluid.littleComponent"],
        "components": {                // List of components to be deployed.
            "kettle server component": { // The name of the server component.
                "type": "kettle.server"  // The type of the server component.
            }
        }
    }
}

Multiple servers

Two kettle.servers with no kettle.apps.

This configuration will deploy two empty server containers.

{
    "typeName": "your configuration name",
    "options": {
        "gradeNames": ["autoInit", "fluid.littleComponent"],
        "components": {
            "server one": {
                "type": "kettle.server"
            },
            "server two": {
                "type": "kettle.server"
            }
        }
    }
}

One server with one app

A single kettle.server that contains a kettle.app.

This configuration will deploy a single server with an empty app that does nothing.

{
    "typeName": "your configuration name",
    "options": {
        "gradeNames": ["autoInit", "fluid.littleComponent"],
        "components": {
            "server": {
                "type": "kettle.server",
                "components": {
                    "kettle app component": {
                        "type": "kettle.app" // For example: "gpii.preferencesServer"
                    }
                }
            }
        }
    }
}

One server with several apps

A single kettle.server that contains two kettle.apps.

This configuration will deploy a single server with two empty apps that do nothing.

{
    "typeName": "your configuration name",
    "options": {
        "gradeNames": ["autoInit", "fluid.littleComponent"],
        "components": {
            "server": {
                "type": "kettle.server",
                "components": {
                    "kettle app component": {
                        "type": "kettle.app"
                    },
                    "preferencesServer": {
                        "type": "gpii.preferencesServer"
                    }
                }
            }
        }
    }
}

Options

Each GPII component is capable of interpreting optional parameters passed to it (these options are meant to override the default setting found in the actual component definition).

  • This configuration will deploy a server on port 80 with logging enabled
{
    "typeName": "your configuration name",
    "options": {
        "gradeNames": ["autoInit", "fluid.littleComponent"],
        "components": {
            "kettle server component": {
                "type": "kettle.server",
                "options": {
                    // Kettle Server options
                    "logging": true,
                    "port": 80
                }
            }
        }
    }
}
  • This configuration will deploy a server with an app that has "some option" setting set to "some option value"
{
    "typeName": "your configuration name",
    "options": {
        "gradeNames": ["autoInit", "fluid.littleComponent"],
        "components": {
            "server": {
                "type": "kettle.server",
                "components": {
                    "kettle app component": {
                        "type": "kettle.app",
                        "options": {
                            "some option": "some option value" // Kettle App option
                        }
                    }
                }
            }
        }
    }
}

Includes

Configuration files are capable of including other existing configuration files to avoid duplication.

This configuration will deploy a server and also load and process the contents of all configuration files mentioned in 'includes' section.

{
    "typeName": "your configuration name",
    "options": {
        "gradeNames": ["autoInit", "fluid.littleComponent"],
        "components": {
            "server": {
                "type": "kettle.server"
            }
        }
    },
    "includes": [
        "relative path to another config file"
    ]
}

Demands (Advanced)

There is another indirect way of configuring all components in the deployment that are not necessarily a kettle.server or a kettle.app. It is done via specific configuration blocks called "demands".

This configuration will deploy a server and also set a "some option" setting set to "some option value" for a "component name we want to configure" when it is created as part of "your configuration name" configuration.

{
    "typeName": "your configuration name", // (*)
    "options": {
        "gradeNames": ["autoInit", "fluid.littleComponent"],
        "components": {
            "server": {
                "type": "kettle.server"
            }
        }
    },
    "demands": [{
        "demandingName": "component name we want to configure",
        // Context in which the component is initialized, in this case
        // it is under the "your configuration name" (*) context.
        "contextNames": "your configuration name",
        "demandSpec": {
            // Component configuration goes here:
            "options": {
                "some option": "some option value"
            }
        }
    }]
}

For more details on how to write demands blocks, see Demands Specifications

Examples of Existing Configuration Files

Below are examples of some of the existing configuration files that are currently used to deploy single Kettle apps or all of GPII architecture.

Preferences Server (Production)

This configuration deploys a preferences server app in a single server container (with logging disabled). We also configure the location of the users store to be at "http://localhost:5984/user/%token". Type of the user store is set to Couch DB (*).

{
    "typeName": "preferencesServer.production",
    "options": {
        "gradeNames": ["autoInit", "fluid.littleComponent"],
        "components": {
            "server": {
                "type": "kettle.server",
                "options": {
                    "logging": false,
                    "components": {
                        "preferencesServer": {
                            "type": "gpii.preferencesServer",
                            "options": {
                                "userSourceUrl": "http://localhost:5984/user/%token"
                            }
                        }
                    }
                }
            }
        }
    },
    "demands": [{
        "demandingName": "rawUserSource",
        "contextNames": "gpii.preferencesServer",
        "demandSpec": {
            "funcName": "kettle.dataSource.CouchDB" // (*)
        }
    }],
    "includes": [
        "./base.json"
    ]
}

Preferences Server (Development)

This configuration deploys a preferences server app in a single server container (with logging enabled). We also configure the location of the users store to be at "file://%root/../../../testData/preferences/%token.json". Type of the user store is set to File (e.g. file path) (*).

{
    "typeName": "preferencesServer.development",
    "options": {
        "gradeNames": ["autoInit", "fluid.littleComponent"],
        "components": {
            "server": {
                "type": "kettle.server",
                "options": {
                    "logging": true,
                    "components": {
                        "preferencesServer": {
                            "type": "gpii.preferencesServer",
                            "options": {
                                "userSourceUrl": "file://%root/../../../testData/preferences/%token.json"
                            }
                        }
                    }
                }
            }
        }
    },
    "demands": [{
        "demandingName": "kettle.urlExpander",
        "contextNames": "gpii.preferencesServer",
        "demandSpec": {
            "funcName": "kettle.urlExpander.development"
        }
    }, {
        "demandingName": "rawUserSource",
        "contextNames": "gpii.preferencesServer",
        "demandSpec": {
            "funcName": "kettle.dataSource.URL" // (*)
        }
    }],
    "includes": [
        "./base.json"
    ]
}

Preferences Server (base)

This configuration defines request handlers specification common between all types of preferences servers.

{
    "demands": [{
        "demandingName": "kettle.requests.request.handler",
        "contextNames": "userGet",
        "demandSpec": {
            "options": {
                "invokers": {
                    "handle": {
                        "funcName": "kettle.requests.request.handler.userGet",
                        "args": ["{requestProxy}", "{request}.req.params.token", "{preferencesServer}.userSource"]
                    }
                }
            }
        }
    }, {
        "demandingName": "kettle.requests.request.handler",
        "contextNames": "userPost",
        "demandSpec": {
            "options": {
                "invokers": {
                    "handle": {
                        "funcName": "kettle.requests.request.handler.userPost",
                        "args": ["{requestProxy}", "{request}.req", "{preferencesServer}.userSource"]
                    }
                }
            }
        }
    }, {
        "demandingName": "userSource",
        "contextNames": "gpii.preferencesServer",
        "demandSpec": {
            "options": {
                "components": {
                    "rawSource": "{rawUserSource}"
                }
            }
        }
    }],
    "modules": [
        "preferencesServer"
    ]
}

Match Maker (Development)

This configuration deploys a match maker app in a single server container (with logging enabled). We also configure the locations of the solutions registry to be at "file://%root/../../../testData/solutions/%os.json" and the ontology server to be at "file://%root/../../../testData/ontologies/ontologies.json".

{
    "typeName": "matchMaker.development",
    "options": {
        "gradeNames": ["autoInit", "fluid.littleComponent"],
        "components": {
            "server": {
                "type": "kettle.server",
                "options": {
                    "logging": true,
                    "components": {
                        "matchMaker": {
                            "type": "gpii.matchMaker",
                            "options": {
                                "solutionsReporterUrl": "file://%root/../../../testData/solutions/%os.json",
                                "ontologyServerUrl": "file://%root/../../../testData/ontologies/ontologies.json"
                            }
                        }
                    }
                }
            }
        }
    },
    "demands": [{
        "demandingName": "kettle.urlExpander",
        "contextNames": "gpii.matchMaker",
        "demandSpec": {
            "funcName": "kettle.urlExpander.development"
        }
    }, {
        "demandingName": "rawOntologyServer",
        "contextNames": "gpii.matchMaker",
        "demandSpec": {
            "funcName": "gpii.ontologyServer.development"
        }
    }],
    "includes": [
        "./base.json"
    ]
}

All of GPII (Development)

We load and process all config files mentioned in 'includes' list and thus deploy a device reporter, a flow manager, a match maker, an ontology server, a preferences server and a solutions registry.

{
    "typeName": "flowManager.preferencesServer.solutionsRegistry.deviceReporter.matchMaker.ontologyServer.development",
    "options": {
        "gradeNames": ["autoInit", "fluid.littleComponent"],
        "components": {
            "server": {
                "type": "kettle.server",
                "options": {
                    "logging": true,
                    "port": 8081
                }
            }
        }
    },
    "includes": [
        "../node_modules/deviceReporter/configs/development.json",
        "../node_modules/flowManager/configs/development.json",
        "../node_modules/matchMaker/configs/development.json",
        "../node_modules/ontologyServer/configs/development.json",
        "../node_modules/preferencesServer/configs/development.json",
        "../node_modules/solutionsRegistry/configs/development.json"
    ]
}

Deploying GPII Architecture Components

Once the configuration file is ready, it is trivial to deploy the configuration on your platform.

Simply execute the following command in your terminal:

[NODE_ENV={environment}] node {universal}/node_modules/kettle/lib/init.js path/to/a/folder/with/your/config

Options

  • environment should correspond to the name of your config file. Default value is 'development'
  • universal is the location of the universal repository

Examples

  • node node_modules/kettle/lib/init.js gpii/node_modules/preferencesServer/configs/
  • NODE_ENV=production node node_modules/kettle/lib/init.js gpii/node_modules/matchMaker/configs/
  • NODE_ENV=ps.sr.production node node_modules/kettle/lib/init.js gpii/configs/