openstack-heat-wrapper

2.2.2 • Public • Published

Openstack-Wrapper

A convenience wrapper for many of Openstack's ecosystem of things

Install

npm install openstack-wrapper

General Usage

Step 1 - Basic Authentication:

//Before any other calls are made into the Openstack system,
//the user must do a general authentication
 
var OSWrap = require('openstack-wrapper');
var keystone = new OSWrap.Keystone('http://www.keystone.url');
 
keystone.getToken('username', 'password', function(error, token){
  if(error)
  {
    console.error('an error occured', error);
  }
  else
  {
    console.log('A general token object has been retrived', token);
    //the token value (token.token) is required for project listing & getting project specific tokens
  }
});

Step 2 - Listing Projects:

//Once a general authentication token value has been obtained
//a project id needs to be found before authenicating to that project
//obviously this listing step can be skipped if one already knows the id
 
var OSWrap = require('openstack-wrapper');
var keystone = new OSWrap.Keystone('http://www.keystone.url');
 
keystone.listProjects('username', 'general_token_value', function(error, projects_array)){
  if(error)
  {
    console.error('an error occured', error);
  }
  else
  {
    console.log('A list of projects was retrived', projects_array);
    //projects_array[n].id is required for many other calls and to generate a project specific token
  }
});

Step 3 - Authenticating for a particular project:

//Once a generic token and a project id have been obtained (through whatever means)
//a project specific token can be generated before instantiating the other library objects
 
var OSWrap = require('openstack-wrapper');
var keystone = new OSWrap.Keystone('http://www.keystone.url');
 
keystone.getProjectToken('general_token_value', 'project_id', function(error, project_token){
  if(error)
  {
    console.error('an error occured', error);
  }
  else
  {
    console.log('A project specific token has been retrived', project_token);
    //the project token contains all kinds of project information
    //including endpoint urls for each of the various systems (Nova, Neutron, Glance)
    //and the token value (project_token.token) required for instantiating all non Keystone Objects
    //see the openstack docs for more specifics on the return format of this object (or print it out I suppose)
  }
});

Step 4 - Other Calls:

//Now that we have a project specific token and the endpoint urls,
//we can instnantiate the other objects (Nova, Neutron, Glance) and call their methods
 
var OSWrap = require('openstack-wrapper');
var nova = new OSWrap.Nova('nova_endpoint_url', 'project_token_value');
 
nova.listServers(function(error, servers_array){
  if(error)
  {
    console.error('an error occured', error);
  }
  else
  {
    console.log('A list of servers have been retrived', servers_array);
    //Other objects (Glance, Neutron, Nova) and their methods follow a nearly identical pattern
  }
});

Simplified Usage:

//A simplified project object is available if the project id is already known
//it will perform both the general and project level authentications
//and return an object with nova, glance, and neutron objects ready to use
 
var OSWrap = require('openstack-wrapper');
OSWrap.getSimpleProject('username', 'password', 'project_id', 'keystone_url', function(error, project){
  if(error)
  {
    console.log('An error occured', error);
  }
  else
  {
    console.log('A Simple Project Object was retrieved', project);
 
    //to use the project object:
    project.nova.listServers(function(error, servers_array){
      if(error)
      {
        console.error('An error occured', error);
      }
      else
      {
        console.log('A list of servers was retrived', servers_array);
      }
    });
  }
});

Objects & Methods

Keystone (aka Identity)

  • new Keystone(v3_public_url)
  • setTimeout(timeout_milliseconds)
  • setLogger(logger_obj)
  • setMangler(mangler_lib) --DEPRECATED
  • getToken(username, password, domain(optional), callback)
  • getProjectTokenById(generic_token_value, project_id, callback)
  • getProjectTokenByName(generic_token_value, domain_id, project_name, callback)
  • listProjects(project_token_value, callback) - token from any project w/admin privledges
  • getProjectByName(project_token_value, project_name, callback) - token from any project w/admin privledges
  • listUserProjects(username, generic_token_value, callback)
  • listRoles(project_token_value, callback)
  • listRoleAssignments(project_token_value, project_id, callback)
  • addRoleAssignment(project_token_value, project_id, entry_id, entry_type, role_id, callback)
  • removeRoleAssignment(project_token_value, project_id, entry_id, entry_type, role_id, callback)
  • listRegions(generic_token_value, callback)

Nova (aka Compute)

  • new Nova(v2_public_url, project_token_value)
  • setTimeout(timeout_milliseconds)
  • setLogger(logger_obj)
  • setMangler(mangler_lib) --DEPRECATED
  • Servers
    • listServers([options], callback)
    • getServer(server_id, callback)
    • createServer(data_object, callback)
    • renameServer(server_id, new_name_string, callback)
    • resizeServer(server_id, flavor_id, callback)
    • confirmResizeServer(server_id, callback)
    • revertResizeServer(server_id, callback)
    • removeServer(server_id, callback)
    • rebootServer(server_id, callback)
    • forceRebootServer(server_id, callback)
    • stopServer(server_id, callback)
    • startServer(server_id, callback)
    • pauseServer(server_id, callback)
    • suspendServer(server_id, callback)
    • resumeServer(server_id, callback)
    • getConsoleURL(console_type_string, server_id, callback)
    • getServerLog(server_id, log_length_integer, callback)
    • createServerImage(server_id, data_object, callback)
    • setMetaData(server_id, data_object, callback)
  • Flavors
    • listFlavors(callback)
    • getFlavor(flavor_id, callback)
  • Project Networks
    • listProjectNetworks(callback)
  • Floating Ips
    • listFloatingIps(callback)
    • listFloatingIps(options, callback)
    • getFloatingIp(floating_ip_id, callback)
    • createFloatingIp(data_object, callback)
    • removeFloatingIp(floating_ip_id, callback)
    • associateFloatingIp(server_id, ip_address, callback)
    • disassociateFloatingIp(server_id, ip_address, callback)
  • Floating IP Pools
    • listFloatingIpPools(callback)
    • getFloatingIpPool(id, callback)
  • Availability Zones
    • listAvailabilityZones(callback)
    • getAvailabilityZone(id, callback)
  • Key Pairs
    • listKeyPairs(callback)
    • getKeyPair(key_pair_id, callback)
    • createKeyPair(key_pair_name, public_key, callback)
    • removeKeyPair(key_pair_id, callback)
  • Quota/Usage
    • getQuotaSet(project_id, callback)
    • setQuotaSet(project_id, data_object, callback)
    • getTenantUsage(project_id, start_date_object, end_date_object, callback)
  • Security Groups
    • assignSecurityGroup(security_group_name, server_id, callback)
    • removeSecurityGroup(security_group_name, server_id, callback)

Glance (aka Image)

  • new Glance(v2_public_url, project_token_value)
  • setTimeout(timeout_milliseconds)
  • setMangler(mangler_lib) --DEPRECATED
  • listImages(callback)
  • getImage(image_id, callback)
  • queueImage(data_object, callback)
  • uploadImage(image_id, stream_object, callback)
  • updateImage(image_id, data_object, callback
  • removeImage(image_id, callback)

Neutron (aka Network)

  • new Neutron(v2_public_url, project_token_value)
  • setTimeout(timeout_milliseconds)
  • setLogger(logger_obj)
  • setMangler(mangler_lib) --DEPRECATED
  • Networks
    • listNetworks(callback(error, array))
    • getNetwork(network_id, callback(error, obj))
  • Routers
    • listRouters(callback(error, array))
    • getRouter(router_id, callback(error, obj))
  • FloatingIps
    • createFloatingIp(floating_network_id, callback(error, obj))
    • listFloatingIps(callback(error, array))
    • getFloatingIp(ip_id, callback(error, obj))
    • updateFloatingIp(ip_id, port_id, callback(error, obj))
    • removeFloatingIp(ip_id, callback(error))
  • Ports
    • listPorts(callback(error, array))
    • listPorts(options, callback(error, array))
    • getPort(port_id, callback(error, obj))
    • updatePort(port_id, data_object, callback(error, obj))
  • Security Groups
    • createSecurityGroup(group_name, data_object, callback(error, obj))
    • listSecurityGroups(project_id, callback(error, array))
    • getSecurityGroup(group_id, callback(error, obj))
    • updateSecurityGroup(group_id, data_object, callback(error, obj))
    • removeSecurityGroup(group_id, callback(error))
  • SecurityGroupRules
    • createSecurityGroupRule(group_id, data_object, callback(error, obj))
    • listSecurityGroupRules(callback(error, array))
    • getSecurityGroupRule(rule_id, callback(error, obj))

Octavia (aka LoadBalancing)

  • new Octavia(v2_public_url, project_token_value)
  • setTimeout(timeout_milliseconds)
  • setRequestID(request_id)
  • setUserName(user_name)
  • setLogger(logger_obj)
  • setRetries(retries_on_locked)
  • setRetryDelay(delay_milliseconds)
  • Load Balancers
    • createLoadBalancer(project_id, options_obj, cb(error, result_obj))
    • listLoadBalancers(cb(error, result_array))
    • getLoadBalancer(loadbalancer_id, cb(error, result_obj))
    • updateLoadBalancer(loadbalancer_id, options_obj, result_obj))
    • removeLoadBalancer(loadbalancer_id, cb(error))
  • LB Listeners
    • createLBListener(loadbalancer_id, protocol, options_obj, cb(error, result_obj))
    • listLBListeners(cb(error, result_array))
    • getLBListener(listener_id, cb(error, result_obj))
    • updateLBListener(listener_id, options_obj, cb(error, result_obj))
    • removeLBListener(listener_id, cb(error))
  • LB Pools
    • createLBPool(protocol, lb_algorithm, options_obj, cb(error, result_obj))
    • listLBPools(cb(error, result_array))
    • getLBPool(pool_id, cb(error, result_obj))
    • updateLBPool(pool_id, options_obj, cb(error, result_obj))
    • removeLBPool(pool_id, cb(error))
  • LB Health Monitors
    • createLBHealthMonitor(pool_id, type, delay, timeout, max_retries, options_obj, cb(error, result_obj))
    • listLBHealthMonitors(cb(error, result_array))
    • getLBHealthMonitor(health_monitor_id, cb(error, result_obj))
    • updateLBHealthMonitor(health_monitor_id, options_obj, cb(error, result_obj))
    • removeLBHealthMonitor(health_monitor_id, cb(error))
  • LB Pool Members
    • createLBPoolMember(pool_id, address, protocol_port, options_obj, cb(error, result_obj))
    • listLBPoolMembers(pool_id, cb(error, result_array))
    • getLBPoolMember(pool_id, member_id, cb(error, result_obj))
    • updateLBPoolMember(pool_id, member_id, options_obj, cb(error, result_obj))
    • removeLBPoolMember(pool_id, member_id, cb(error))

Heat (aka Orchestration)

  • new Heat(v1_public_url, project_token_value)
  • setTimeout(timeout_milliseconds)
  • Stacks
    • listStacks(options_obj, cb(error, result_obj))
    • createStack(stack_name, options_obj, cb(error, result_obj))
    • updateStack(stack_name, stack_id, options_obj, cb(error, result_obj))
    • deleteStack(stack_name, stack_id, cb(error, result_obj))

Running Tests

To run the tests:

cd openstack_wrapper/
npm install
npm test

Change Log

2.2.0

  • Updated Nova.createServerImage to handle Nova 2.45+ format (new output format breaks backwards compat on this method so incrimented minor ver)

2.1.13

  • Added Heat object and methods

2.1.12

  • Added project network listing to Nova

2.1.11

  • Added region listing to Keystone

2.1.8

  • Added optional filtering on server listing calls

2.1.0

  • Added Octavia calls for LoadBalancers, Listeners, Pools, HealthChecks, and Members
  • Mangling is now Deprecated and not available in any new methods (like the Octavia ones) because 1-way mangling was a bad idea 2-way is better implemented in-app

2.0.0

  • Added support for a logger object instead of replacing entire request object to faciliate remote call logging.
  • Removed multiple error types. All methods now return a general error with a 'detail' property containing call details if a call was made
  • Removed global timeout feature (too confusing when that was/wasn't in play)

1.4.0

  • Removed usage of OpenStackErrors. Specifically removed all references of isError() & getError() in favor of: isRequestError() & getRequestError().
  • Added structures for additional neutron functionality to be released in 1.5.X

License

Copyright (c) 2014 Go Daddy Operating Company, LLC

See LICENSE.txt for more info.

Package Sidebar

Install

npm i openstack-heat-wrapper

Weekly Downloads

0

Version

2.2.2

License

MIT

Unpacked Size

327 kB

Total Files

20

Last publish

Collaborators

  • johncao