Submodules¶

paradrop.backend.exc.executionplan module¶

abortPlans(update)[source]¶

This function should be called if one of the Plan objects throws an Exception. It takes the PlanMap argument and calls the getNextAbort function just like executePlans does with todoPlans. This dynamically generates an abort plan list based on what plans were originally executed. Returns:

True in error : This is really bad False otherwise : we were able to restore system state back to before the executeplans function was called

aggregatePlans(update)[source]¶

Takes the PlanMap provided which can be a combination of changes for multiple different chutes and it puts things into a sane order and removes duplicates where possible.

This keeps things like reloading networking from happening twice if 2 chutes make changes.

Returns:

A new PlanMap that should be executed

executePlans(update)[source]¶

Primary function that actually executes all the functions that were added to plans by all the exc modules. This function can heavily modify the OS/files/etc.. so the return value is very important. Returns:

True in error : abortPlans function should be called False otherwise : everything is OK

generatePlans(update)[source]¶

For an update object provided this function references the updateModuleList which lets all exc modules determine if they need to add functions to change the state of the system when new chutes are added to the OS.

Returns: True in error, as in we should stop with this update plan

paradrop.backend.exc.files module¶

generateFilesPlan(chuteStor, newChute, chutePlan)[source]¶

This function looks at a diff of the current Chute (in @chuteStor) and the @newChute, then adds Plan() calls to make the Chute match the @newChute.

Returns:

None : means continue to pass this chute update to the rest of the chain. True : means stop updating, but its ok (no errors or anything) str : means stop updating, but some error occured (contained in the string)

generatePlans(update)[source]¶

This function looks at a diff of the current Chute (in @chuteStor) and the @newChute, then adds Plan() calls to make the Chute match the @newChute.

Returns:

True: abort the plan generation process

paradrop.backend.exc.name module¶

generatePlans(update)[source]¶

This function looks at a diff of the current Chute (in @chuteStor) and the @newChute, then adds Plan() calls to make the Chute match the @newChute.

Returns:

True: abort the plan generation process

paradrop.backend.exc.plangraph module¶

class Plan(func, *args)[source]¶

Helper class to hold onto the actual plan data associated with each plan

class PlanMap(name)[source]¶

This class helps build a dependency graph required to determine what steps are required to update a Chute from a previous version of its configuration.

addMap(other)[source]¶

Takes another PlanMap object and appends whatever the plans are into this plans object.

addPlans(priority, todoPlan, abortPlan=[])[source]¶

Adds new Plan objects into the list of plans for this PlanMap.

Arguments:

@priority : The priority number (1 is done first, 99 done last - see PRIORITYFLAGS section at top of this file) @todoPlan : A tuple of (function, (args)), this is the function that completes the actual task requested

the args can either be a single variable, a tuple of variables, or None.

@abortPlan : A tuple of (function, (args)) or None. This is what should be called if a plan somewhere in the chain

fails and we need to undo the work we did here - this function is only called if a higher priority function fails (ie we were called, then something later on fails that would cause us to undo everything we did to setup/change the Chute).

getNextAbort()[source]¶

Like an iterator function, it returns each element in the list of abort plans in order.

Returns:

(function, args) : Each todo is returned just how the user first added it None : None is returned when there are no more todo’s

getNextTodo()[source]¶

Like an iterator function, it returns each element in the list of plans in order.

Returns:

(function, args) : Each todo is returned just how the user first added it None : None is returned when there are no more todo’s

registerSkip(func)[source]¶

Register this function as one to skip execution on, if provided it shouldn’t return the (func, args) tuple as a result from the getNextTodo function.

sort()[source]¶

Sorts the plans based on priority.

paradrop.backend.exc.resource module¶

generatePlans(update)[source]¶

This function looks at a diff of the current Chute (in @chuteStor) and the @newChute, then adds Plan() calls to make the Chute match the @newChute.

Returns:

True: abort the plan generation process

generateResourcePlan(chuteStor, newChute, chutePlan)[source]¶

This function looks at a diff of the current Chute (in @chuteStor) and the @newChute, then adds Plan() calls to make the Chute match the @newChute.

Returns:

None : means continue to pass this chute update to the rest of the chain. True : means stop updating, but its ok (no errors or anything) str : means stop updating, but some error occured (contained in the string)

paradrop.backend.exc.runtime module¶

generatePlans(update)[source]¶

This function looks at a diff of the current Chute (in @chuteStor) and the @newChute, then adds Plan() calls to make the Chute match the @newChute.

Returns:

True: abort the plan generation process

paradrop.backend.exc.state module¶

generatePlans(update)[source]¶

This function looks at a diff of the current Chute (in @chuteStor) and the @newChute, then adds Plan() calls to make the Chute match the @newChute.

Returns:

True: abort the plan generation process

generateStatePlan(chuteStor, newChute, chutePlan)[source]¶

This function looks at a diff of the current Chute (in @chuteStor) and the @newChute, then adds Plan() calls to make the Chute match the @newChute.

Returns:

None : means continue to pass this chute update to the rest of the chain. True : means stop updating, but its ok (no errors or anything) str : means stop updating, but some error occured (contained in the string)

paradrop.backend.exc.struct module¶

generatePlans(update)[source]¶

This function looks at a diff of the current Chute (in @chuteStor) and the @newChute, then adds Plan() calls to make the Chute match the @newChute.

Returns:

True: abort the plan generation process

paradrop.backend.exc.traffic module¶

generatePlans(update)[source]¶

This function looks at a diff of the current Chute (in @chuteStor) and the @newChute, then adds Plan() calls to make the Chute match the @newChute.

Returns:

True: abort the plan generation process

generateTrafficPlan(chuteStor, newChute, chutePlan)[source]¶

This function looks at a diff of the current Chute (in @chuteStor) and the @newChute, then adds Plan() calls to make the Chute match the @newChute.

Returns:

None : means continue to pass this chute update to the rest of the chain. True : means stop updating, but its ok (no errors or anything) str : means stop updating, but some error occured (contained in the string)

Module contents¶

Submodules¶

paradrop.backend.fc.chutestorage module¶

class ChuteStorage(filename=None, reactor=None)[source]¶

Bases: paradrop.lib.utils.storage.PDStorage

ChuteStorage class.

This class holds onto the list of Chutes on this AP.

It implements the PDStorage class which allows us to save the chuteList to disk transparently

attrSaveable()[source]¶

Returns True if we should save the ChuteList, otherwise False.

chuteList = {}¶

clearChuteStorage()[source]¶

deleteChute(ch)[source]¶

Deletes a chute from the chute storage. Can be sent the chute object, or the chute name.

getAttr()[source]¶

Get our attr (as class variable for all to see)

getChute(name)[source]¶

Returns a reference to a chute we have in our cache, or None.

getChuteList()[source]¶

Return a list of the GUIDs of the chutes we know of.

saveChute(ch)[source]¶

Saves the chute provided in our internal chuteList. Also since we just received a new chute to hold onto we should save our ChuteList to disk.

setAttr(attr)[source]¶

Save our attr however we want (as class variable for all to see)

paradrop.backend.fc.configurer module¶

class PDConfigurer(storage, lclReactor)[source]¶

ParaDropConfigurer class. This class is in charge of making the configuration changes required on the chutes. It utilizes the ChuteStorage class to hold onto the chute data.

Use @updateChutes to make the configuration changes on the AP.

This function is thread-safe, this class will only call one update set at a time. All others are held in a queue until the last update is complete.

clearUpdateList()[source]¶

MUTEX: updateLock Clears all updates from list (new array).

getNextUpdate()[source]¶

MUTEX: updateLock Returns the size of the local update queue.

performUpdates()[source]¶

This is the main working function of the PDConfigurer class. It should be executed as a separate thread, it does the following:

checks for any updates to perform does them responds to the server removes the update checks for more updates

if more exist it calls itself again more quickly else it puts itself to sleep for a little while

updateList(**updateObj)[source]¶

MUTEX: updateLock Take the list of Chutes and push the list into a queue object, this object will then call the real update function in another thread so the function that called us is not blocked.

We take a callable responseFunction to call, when we are done with this update we should call it.

paradrop.backend.fc.updateObject module¶

updateObject module.

This holds onto the UpdateObject class. It allows us to easily abstract away different update types and provide a uniform way to interpret the results through a set of basic actionable functions.

class UpdateChute(obj)[source]¶

Bases: paradrop.backend.fc.updateObject.UpdateObject

Updates specifically tailored to chute actions like create, delete, etc...

saveState()[source]¶

For chutes specifically we need to change the chuteStor object to reflect the new state of the system after a chute update. Perform that update here.

updateModuleList = [<module 'paradrop.backend.exc.name' from '/home/docs/checkouts/readthedocs.org/user_builds/paradrop/checkouts/v0.1/paradrop/paradrop/backend/exc/name.pyc'>, <module 'paradrop.backend.exc.state' from '/home/docs/checkouts/readthedocs.org/user_builds/paradrop/checkouts/v0.1/paradrop/paradrop/backend/exc/state.pyc'>, <module 'paradrop.backend.exc.struct' from '/home/docs/checkouts/readthedocs.org/user_builds/paradrop/checkouts/v0.1/paradrop/paradrop/backend/exc/struct.pyc'>, <module 'paradrop.backend.exc.resource' from '/home/docs/checkouts/readthedocs.org/user_builds/paradrop/checkouts/v0.1/paradrop/paradrop/backend/exc/resource.pyc'>, <module 'paradrop.backend.exc.traffic' from '/home/docs/checkouts/readthedocs.org/user_builds/paradrop/checkouts/v0.1/paradrop/paradrop/backend/exc/traffic.pyc'>, <module 'paradrop.backend.exc.runtime' from '/home/docs/checkouts/readthedocs.org/user_builds/paradrop/checkouts/v0.1/paradrop/paradrop/backend/exc/runtime.pyc'>]¶

class UpdateObject(obj)[source]¶

Bases: object

The base UpdateObject class, covers a few basic methods but otherwise all the intelligence exists in the inherited classes.

All update information passed by the API server is contained as variables of this class such as update.updateType, update.updateClass, etc...

By default, the following variables should be utilized:

responses : an array of messages any module can choose to append warnings or errors to

failure : the module that chose to fail this update can set a string message to return

: to the user in the failure variable. It should be very clear as to why the : failure occurred, but if the user wants more information they may find it : in the responses variable which may contain debug information, etc...

complete(**kwargs)[source]¶

Signal to the API server that any action we need to perform is complete and the API server can finish its connection with the client that initiated the API request.

execute()[source]¶

The function that actually walks through the main process required to create the chute. It follows the executeplan module through the paces of:

1. Generate the plans for each exc module
2. Prioritize the plans
3. Execute the plans

If at any point we fail then this function will directly take care of completing the update process with an error state and will close the API connection.

saveState()[source]¶

Function should be overwritten for each UpdateObject subtype

updateModuleList = []¶

parse(obj)[source]¶

Determines the update type and returns the proper class.

Module contents¶

Subpackages¶

Submodules¶

paradrop.backend.pdconfd.client module¶

class Blocking(deferred)[source]¶

Bases: object

Uses threading.Event to implement blocking on a twisted deferred object.

The wait method will wait for its completion and return its result.

Dear Lance. I hope you stub your toe.

unlock(result)[source]¶

wait()[source]¶

callDeferredMethod(*args, **kwargs)[source]¶

reload(path, dbus=False)[source]¶

Reload file(s) specified by path.

This function blocks until the request completes. On completion it returns a status string, which is a JSON list of loaded configuration sections with a ‘success’ field. For critical errors such as failure to connect to the D-Bus service, it will return None.

reloadAll(dbus=False)[source]¶

Reload all files from the system configuration directory.

This function blocks until the request completes. On completion it returns a status string, which is a JSON list of loaded configuration sections with a ‘success’ field. For critical errors such as failure to connect to the D-Bus service, it will return None.

waitSystemUp(dbus=False)[source]¶

Wait for the configuration daemon to finish its first load.

This function blocks until the request completes. On completion it returns a status string, which is a JSON list of loaded configuration sections with a ‘success’ field. For critical errors such as failure to connect to the D-Bus service, it will return None.

paradrop.backend.pdconfd.main module¶

This module listens for D-Bus messages and triggers reloading of configuration files. This module is the service side of the implementation. If you want to issue reload commands to the service, see the client.py file instead.

Operation:

• When triggered, read in UCI configuration files.
• Pass sections off to appropriate handlers (interface, etc.).
• Perform some validation (check for required options).
• Emit commands (start/stop daemon, ip, iw, etc.) into a queue.
• Issue commands, maybe rollback on failure.
• Update known state of the system.

Reference: http://excid3.com/blog/an-actually-decent-python-dbus-tutorial/

class ConfigService[source]¶

Bases: txdbus.objects.DBusObject

configManager = None¶

dbusInterfaces = [<txdbus.interface.DBusInterface object at 0x7fdefdf02750>]¶

dbus_Reload(name)[source]¶

dbus_ReloadAll()[source]¶

dbus_Test()[source]¶

dbus_UnloadAll()[source]¶

dbus_WaitSystemUp()[source]¶

listen(*args, **kwargs)[source]¶

run_pdconfd()[source]¶

Start pdconfd daemon.

This enters the pdconfd main loop.

run_thread()[source]¶

Start pdconfd service as a thread.

This function schedules pdconfd to run as a thread and returns immediately.

Module contents¶

Submodules¶

paradrop.backend.pdfcd.apichute module¶

class ChuteAPI(rest)[source]¶

The Chute API submodule. This class handles all API calls related to actionable items that directly effect chutes.

POST_createChute(theSelf, request, *args, **kwargs)¶

POST_deleteChute(theSelf, request, *args, **kwargs)¶

POST_startChute(theSelf, request, *args, **kwargs)¶

POST_stopChute(theSelf, request, *args, **kwargs)¶

paradrop.backend.pdfcd.apiinternal module¶

class Base(module, **kwargs)[source]¶

Bases: twisted.web.xmlrpc.XMLRPC

lookupProcedure(procedurePath)[source]¶

class ServerPerspective(name, realm)[source]¶

Bases: pdtools.lib.riffle.RifflePerspective

destroy()[source]¶

initialize()[source]¶

perspective_subscribeLogs(*args, **kwargs)[source]¶

Fetch all logs since the target time. Stream all new logs to the server as they come in.

class ToolsPerspective(name, realm)[source]¶

Bases: pdtools.lib.riffle.RifflePerspective

apiWrapper(target)[source]¶

Add a final line of error and success callbacks before going onto the wire

api_provision(*args, **kwargs)[source]¶

Provision this router with an id and a set of keys.

This is a temporary call until the provisioning process is finalized.

castFailure(failure)[source]¶

Converts an exception (or general failure) into an xmlrpc fault for transmission.

castSuccess(res)[source]¶

checkStartRiffle()[source]¶

Temporary function. Do not start serving or connecting over riffle until we have our keys (which occurs during currently optional provisioning)

pollServer(host)[source]¶

Poll the server for a connection.

paradrop.backend.pdfcd.apiutils module¶

backend.pdfcd.apiutils. Contains helper functions specific to the backend API code.

addressInNetwork(ipaddr, netTuple)[source]¶

This function allows you to check if on IP belongs to a Network. Arguments:

unpacked IP address (use unpackIPAddr()) tuple of unpacked (addr, netmask) (use unpackIPAddrWithSlash())

Returns:

True if in network False otherwise

calcDottedNetmask(mask)[source]¶

Returns quad dot format of IP address.

getIP(req)[source]¶

Returns the str IP addr from the request. NOTE: This is required because when we use nginx servers it is used as a proxy, so the REAL IP addr is stored in a HTTP header called ‘X-Real-IP’, so we need to check for this first, otherwise the request.getClientIP() is always going to return ‘localhost’ to us.

unpackIPAddr(ip)[source]¶

Unpacks the ‘IP’ str. Returns a binary form of the ipaddr such that (ipaddr & netmask) will work.

unpackIPAddrWithSlash(net)[source]¶

Unpacks the ‘IP/bitmask’ str. Returns a tuple of binary forms of both the ipaddr and netmask such that (ipaddr & netmask) will work.

paradrop.backend.pdfcd.server module¶

pdfcd.server. Contains the classes required to establish a RESTful API server using Twisted.

class ParadropAPIServer(*args, **kwargs)[source]¶

Bases: paradrop.lib.api.pdrest.APIResource

The main API server module.

This sets up all of the submodules which should contain different types of RESTful API calls.

GET_test(request)[source]¶

A Simple test method to ping if the API server is working properly.

complete(update)[source]¶

Kicks off the properly threaded call to complete the API call that was passed to PDConfigurer. Since the PDConfigurer module has its own thread that runs outside of the main event loop, we have to call back into the event system properly in order to keep any issues of concurrency at bay.

default(request)[source]¶

A dummy catch for all API calls that are not caught by any other module.

failprocess(ip, request, logFailure, errorStmt, logUsage, errType)[source]¶

If logFailure is not None, Update the failureDict when the request does something wrong If logUsage is not None, log the usage track info.

Arguments:

ip : IP of client request : the request we received logFailure : If none, we do not log this failure to failure dict. Otherwise it is a tuple of

key : the key to use in the failureDict failureDict : the dict record the failure attempt history

errorStmt : A string to return to the user, looks like ‘Malformed Body: %s’

so that we can add things like “Number of attempts remaining: 2” to the response

logUsage : A tuple of (tictoc and devid) used for usage tracker errorResponse: The error code to set response code

Returns:

String to respond to the client

postprocess(request, key, failureDict, logUsage)[source]¶

If the client is successful in their request, we should: * reset their failure attempts if failureDict is not none. * set success response code * If usage is not none, add usage track info of the api call

preprocess(request, checkThresh, tictoc)[source]¶

Check if failure attempts for the user name has met the threshold. Arguments:

request : checkThresh : If None, no checking. Tuple of arguments for checking thresholds

ip: IP of client in string format token: sessionToken if found, or None username: username if signin, or None failureDict: the dict for failure history

ticktoc: If none, do not track the usage. The start time of the API call

Return:

str: if threshold is met None: if ok

initializeSystem()[source]¶

Perform some initialization steps such as writing important configuration.

setup(args=None)[source]¶

This is the main setup function to establish the TCP listening logic for the API server. This code also takes into account development or unit test mode.

Module contents¶

Submodules¶

paradrop.lib.api.pdapi module¶

exception PDAPIError(etype, msg)[source]¶

Bases: exceptions.Exception

Exception class related to ParaDrop API calls.

getErrorToken()[source]¶

Generates a random string which is used to match client issues with log output.

getResponse(code, *args)[source]¶

Designed to be called to provide the arguments for the Request.setResponseCode()

isPDError(code)[source]¶

Checks all Paradrop API error codes, if the HTTP code is in our set it is assumed a PDAPI error.

paradrop.lib.api.pdrest module¶

ALL(regex)¶

APIDecorator(admin=False, permission=None, requiredArgs=[], optionalArgs=[])[source]¶

The decorator for the API functions to make the API functions focus on their job. This decorator do the following things:

• Set HTTP header
• Get some common values like ip, tictoc
• Do the preprocess
• Extract arguments from HTTP body and put them into APIPackage
• Get devid if token is shown and put devid into APIPackage
• Check admin authorization if devid is shown and admin argument is set to be true
• Do the failprocess if fails. Do the postProcess if success

This decorator will pass an APIPackage to an API function and the API function is supposed to put return value into the API package Arguments:

• admin: if the function needs admin authority to call
• requiredArgs: the required arguments for this API, this wrapper will parse the required args from HTTP body and check if they exist in the body.
• optionalArgs: the optional arguments for this API, the args will be parsed from HTTP body
• permission: choose from None, “AP Owner”, “Chute Owner”

TODO:

1.Permission

• multiple permission/multiple level of permission??
• More permissions: such as Vnet Owner, Group Owner

class APIPackage(request)[source]¶

This is a class that wrap up the input and return value of API The input arguments will be in the inputArgs as a dict Result is True means the API return success Result is False means the API return failure Result is None means the API return NOT_YET_DONE

setFailure(errType, errMsg=None, countFailure=True)[source]¶

setNotDoneYet()[source]¶

setSuccess(returnVal)[source]¶

class APIResource(*args, **kwargs)[source]¶

Bases: twisted.web.resource.Resource

getChild(name, request)[source]¶

register(method, regex, callback)[source]¶

unregister(method=None, regex=None, callback=None)[source]¶

DELETE(regex)¶

GET(regex)¶

POST(regex)¶

PUT(regex)¶

maybeResource(f)[source]¶

method_factory_factory(method)[source]¶

Module contents¶

Submodules¶

paradrop.lib.config.configservice module¶

configservice module:

This module is responsible for “poking” the proper host OS services to change the host OS config. This would include things like changing the networking, DHCP server settings, wifi, etc..

reloadAll(update)[source]¶

reloadQos(update)[source]¶

paradrop.lib.config.devices module¶

Detect physical devices that can be used by chutes.

This module detects physical devices (for now just network interfaces) that can be used by chutes. This includes WAN interfaces for Internet connectivity and WiFi interfaces which can host APs.

It also makes sure certain entries exist in the system UCI files for these devices, for example “wifi-device” sections. These are shared between chutes, so they only need to be added when missing.

getSystemDevices(update)[source]¶

Detect devices on the system.

Store device information in cache key “networkDevices”.

isVirtual(ifname)[source]¶

Test if an interface is a virtual one.

FIXME: This just tests for the presence of certain strings in the interface name, so it is not very robust.

isWAN(ifname)[source]¶

Test if an interface is a WAN interface.

isWireless(ifname)[source]¶

Test if an interface is a wireless device.

setConfig(chuteName, sections, filepath)[source]¶

setSystemDevices(update)[source]¶

Initialize system configuration files.

Creates basic sections that all chutes require such as the “wan” interface.

paradrop.lib.config.dhcp module¶

getVirtDHCPSettings(update)[source]¶

Looks at the runtime rules the developer defined to see if they want a dhcp server. If so it generates the data and stores it into the chute cache key:virtDHCPSettings.

setVirtDHCPSettings(update)[source]¶

Takes a list of tuples (config, opts) and saves it to the dhcp config file.

paradrop.lib.config.dockerconfig module¶

getVirtPreamble(update)[source]¶

paradrop.lib.config.firewall module¶

findMatchingInterface(iface_name, interfaces)[source]¶

Search an interface list for one matching a given name.

iface_name can contain shell-style wildcards (* and ?).

getDeveloperFirewallRules(update)[source]¶

Generate other firewall rules requested by the developer such as redirects. The object returned is a list of tuples (config, options).

getOSFirewallRules(update)[source]¶

There is a set of default things that must exist just for the chute to function at all, generate those here.

Stored in key: osFirewallRules

setOSFirewallRules(update)[source]¶

Takes a list of tuples (config, opts) and saves it to the firewall config file.

paradrop.lib.config.network module¶

abortNetworkConfig(update)[source]¶

Release resources claimed by chute network configuration.

getNetworkConfig(update)[source]¶

For the Chute provided, return the dict object of a 100% filled out configuration set of network configuration. This would include determining what the IP addresses, interfaces names, etc...

getOSNetworkConfig(update)[source]¶

Takes the network interface obj created by NetworkManager.getNetworkConfiguration and returns a properly formatted object to be passed to the OpenWrtConfig class. The object returned is a list of tuples (config, options).

getVirtNetworkConfig(update)[source]¶

interfaceDefsEqual(iface1, iface2)[source]¶

reclaimNetworkResources(chute)[source]¶

Reclaim network resources for a previously running chute.

This function only applies to the special case in which pd starts up and loads a list of chutes that were running. This function marks their IP addresses and interface names as taken so that new chutes will not use the same values.

setOSNetworkConfig(update)[source]¶

Takes a list of tuples (config, opts) and saves it to the network config file.

paradrop.lib.config.osconfig module¶

osconfig module:

This module is in charge of changing configuration files for pdfcd on the host OS. This relates to things like network, dhcp, wifi, firewall changes. Pdfcd should be able to make simple abstracted calls into this module so that if we need to change what type of OS config we need to support only this module would change.

revertConfig(update, theType)[source]¶

Basically the UCI system saves a backup of the original config file, if we need to revert changes at all, we can just tell our UCI module to revert back using that backup copy.

paradrop.lib.config.pool module¶

class NetworkPool(network, subnetSize=24)[source]¶

Bases: paradrop.lib.config.pool.ResourcePool

class NumericPool(digits=4)[source]¶

Bases: paradrop.lib.config.pool.ResourcePool

class ResourcePool(values, numValues)[source]¶

Bases: object

next()[source]¶

release(item)[source]¶

reserve(item, strict=True)[source]¶

Mark item as used.

If strict is True, raises an exception if the item is already used.

paradrop.lib.config.uciutils module¶

appendListItem(options, name, value)[source]¶

Add a list item to UCI options.

The way we store lists for UCI options is rather bizarre, so this function takes care of that.

options: dictionary of options for a UCI section name: string name of the list option value: string value to append

removeConfigs(chute, cacheKeys, filepath)[source]¶

used to modify config file of each various setting in /etc/config/

restoreConfigFile(chute, configname)[source]¶

Restore a system config file from backup.

This can only be used during a chute update operation to revert changes that were made during that update operation.

configname: name of configuration file (“network”, “wireless”, etc.)

setConfig(chute, old, cacheKeys, filepath)[source]¶

Helper function used to modify config file of each various setting in /etc/config/ Returns:

True: if it modified a file False: if it did NOT cause any modifications

setList(options, name, values)[source]¶

Set a list item in UCI options.

The way we store lists for UCI options is rather bizarre, so this function takes care of that.

options: dictionary of options for a UCI section name: string name of the list option values: list of string values

paradrop.lib.config.wifi module¶

getOSWirelessConfig(update)[source]¶

setOSWirelessConfig(update)[source]¶

Module contents¶

Submodules¶

paradrop.lib.utils.addresses module¶

areWanPortsAvailable(portRange, takenPorts, chuteStor, name)[source]¶

Make sure that if we are forwarding a wan port, we have not already forwarded it.

checkPhyExists(radioid)[source]¶

Check if this chute exists at all, a directory /sys/class/ieee80211/phyX must exist.

getChuteIntf(name, netIntfs)[source]¶

This function takes a network interface name, and parses through the netIntfs object provided looking for a match, it returns name if none is found.

Example:

if ‘lan’ is the name, ‘lan’ will be returned. if ‘wifilxc’ is the name, ‘c####wifilxc’ will be returned.

This function also deals with the usage of macro expansions:

Example:

If the developer defines a ‘lan’ interface for their chute, but they also have a rule that needs to point to the HOST lan interface, a conflict will occur.

To solve this, the developer would specify the HOST lan with '@net.host.lan‘ and the chute lan with ‘lan’.

getGatewayIntf(ch)[source]¶

Looks at the key:networkInterfaces for the chute and determines what the gateway should be including the IP address and the internal interface name.

Returns:

A tuple (gatewayIP, gatewayInterface) None if networkInterfaces doesn’t exist or there is an error

getInternalIntfList(ch)[source]¶

Takes a chute object and uses the key:networkInterfaces to return a list of the internal network interfaces that will exist in the chute (e.g., eth0, eth1, ...)

Returns:

A list of interface names None if networkInterfaces doesn’t exist or there is an error

getSubnet(ip1, sn1)[source]¶

getWANIntf(ch)[source]¶

Looks at the key:networkInterfaces for the chute and finds the WAN interface.

Returns:

The dict from networkInterfaces None

incIpaddr(ipaddr, inc=1)[source]¶

Takes a quad dot format IP address string and adds the @inc value to it by converting it to a number.

Returns:

Incremented quad dot IP string or None if error

isIpAvailable(ipaddr, chuteStor, name)[source]¶

Make sure this IP address is available. Checks the IP addresses of all zones on all other chutes,

makes sure subnets are not the same.

isIpValid(ipaddr)[source]¶

Return True if Valid, otherwise False.

isRadioPassedthrough(radioid, chuteStor, name)[source]¶

Check if any chute has already passed through to a chute.

isSameSubnet(ip1, ip2)[source]¶

isStaMeshAvailable(chuteStor, name)[source]¶

Make sure this sta/mesh is available. Only one per device because we attach to wan directly.

isStaMeshOnRadio(radioid, chuteStor, name)[source]¶

If we are a wifi chute, we cannot have an sta on this channel.

isStaticIpAvailable(ipaddr, chuteStor, name)[source]¶

Make sure this static IP address is available. Checks the IP addresses of all zones on all other chutes,

makes sure not equal.

isWifiIntAvailable(radioid, numWifi, chuteStor, name)[source]¶

Make sure that fewer than 7 wifi interfaces have been configured. Otherwise, the wireless card will fail.

isWifiOnRadio(radioid, chuteStor, name)[source]¶

Make sure this sta is available. Only one per device because we attach to wan directly.

isWifiSSIDAvailable(ssid, chuteStor, name)[source]¶

Make sure this SSID is available.

maxIpaddr(ipaddr)[source]¶

Takes a quad dot format IP address string and makes it the largest valid value still in the same subnet.

Returns:

Incremented quad dot IP string or None if error

paradrop.lib.utils.dockerapi module¶

Functions associated with deploying and cleaning up docker containers.

build_host_config(update)[source]¶

Build the host_config dict for a docker container based on the passed in update.

Parameters:	update (obj) – The update object containing information about the chute.
Returns:	(dict) The host_config dict which docker needs in order to create the container.

failAndCleanUpDocker(validImages, validContainers)[source]¶

Clean up any intermediate containers that may have resulted from a failure and throw an Exception so that the abort process is called.

Parameters:	validImages (list) – A list of dicts containing the Id’s of all the images that should exist on the system. validContainers (list) – A list of the Id’s of all the containers that should exist on the system.
Returns:	None

removeChute(update)[source]¶

Remove a docker container and the image it was built on based on the passed in update.

Parameters:	update (obj) – The update object containing information about the chute.
Returns:	None

restartChute(update)[source]¶

Start a docker container based on the passed in update.

Parameters:	update (obj) – The update object containing information about the chute.
Returns:	None

setup_net_interfaces(update)[source]¶

Link interfaces in the host to the internal interface in the docker container using pipework.

Parameters:	update (obj) – The update object containing information about the chute.
Returns:	None

startChute(update)[source]¶

Build and deploy a docker container based on the passed in update.

Parameters:	update (obj) – The update object containing information about the chute.
Returns:	None

stopChute(update)[source]¶

Stop a docker container based on the passed in update.

Parameters:	update (obj) – The update object containing information about the chute.
Returns:	None

writeDockerConfig()[source]¶

Write options to Docker configuration.

Mainly, we want to tell Docker not to start containers automatically on system boot.

paradrop.lib.utils.pdos module¶

basename(x)¶

copy(a, b)[source]¶

copytree(a, b)[source]¶

shutil’s copytree is dumb so use distutils.

doMount(part, mnt)[source]¶

This function mounts @part to @mnt.

doUnmount(mnt)[source]¶

This function unmounts @mnt.

exists(p)[source]¶

fixpath(p)[source]¶

This function is required because if we need to pass a path to something like tarfile, we cannot overwrite the function to fix the path, so we need to expose it somehow.

getFileType(f)[source]¶

getMountCmd()[source]¶

isMount(mnt)[source]¶

This function checks if @mnt is actually mounted.

isdir(a)[source]¶

isfile(a)[source]¶

ismount(p)[source]¶

makeExecutable(*args)[source]¶

The function that takes the list of files provided and sets the X bit on them.

mkdir(p)[source]¶

move(a, b)[source]¶

open(p, mode)[source]¶

oscall(cmd, get=False)[source]¶

This function performs a OS subprocess call. All output is thrown away unless an error has occured or if @get is True Arguments:

@cmd: the string command to run [get] : True means return (stdout, stderr)

Returns:

None if not @get and no error (stdout, retcode, stderr) if @get or yes error

readFile(filename, array=True, delimiter='\n')[source]¶

Reads in a file, the contents is NOT expected to be binary. Arguments:

@filename: absolute path to file @array : optional: return as array if true, return as string if False @delimiter: optional: if returning as a string, this str specifies what to use to join the lines

Returns:

A list of strings, separated by newlines None: if the file doesn’t exist

remove(a)[source]¶

symlink(a, b)[source]¶

syncFS()[source]¶

unlink(p)[source]¶

write(filename, data, mode='w')[source]¶

Writes out a config file to the specified location.

writeFile(filename, line, mode='a')[source]¶

Adds the following cfg (either str or list(str)) to this Chute’s current config file (just stored locally, not written to file.

paradrop.lib.utils.pdosq module¶

Quiet pdos module. Implements utility OS operations without relying on the output module. Therefore, this module can be used by output without circular dependency.

makedirs(p)[source]¶

Recursive directory creation (like mkdir -p). Returns True if the path is successfully created, False if it existed already, and raises an OSError on other error conditions.

paradrop.lib.utils.restart module¶

lib.utils.restart Contains the functions required to restart chutes properly on power cycle of device. Checks with pdconfd to make sure it was able to properly bring up all interfaces before starting chutes.

reloadChutes()[source]¶

This function is called to restart any chutes that were running prior to the system being restarted. It waits for pdconfd to come up and report whether or not it failed to bring up any of the interfaces that existed before the power cycle. If pdconfd indicates something failed we then force a stop update in order to bring down all interfaces associated with that chute and mark it with a warning. If the stop fails we mark the chute with a warning manually and change its state to stopped and save to storage this isn’t great as it could mean our system still has interfaces up associated with that chute. If pdconfd doesn’t report failure we attempt to start the chute and if this fails we trust the abort process to restore the system to a consistent state and we manually mark the chute as stopped and add a warning to it. :param None :returns: (list) A list of update dicts to be used to create updateObjects that should be run before accepting new updates.

updateStatus(update)[source]¶

This function is a callback for the updates we do upon restarting the system. It checks whether or not the update completed successfully and if not it changes the state of the chute to stopped and adds a warning. :param update: The update object containing information about the chute that was created and whether it was successful or not. :type update: obj :returns: None

paradrop.lib.utils.storage module¶

class PDStorage(filename, reactor, saveTimer)[source]¶

ParaDropStorage class.

This class is designed to be implemented by other classes. Its purpose is to make whatever data is considered important persistant to disk.

This is done by providing a reactor so a “LoopingCall” can be utilized to save to disk.

The implementer can override functions in order to implement this class:

getAttr() : Get the attr we need to save to disk setAttr() : Set the attr we got from disk importAttr(): Takes a payload and returns the properly formatted data exportAttr(): Takes the data and returns a payload attrSaveable(): Returns True if we should save this attr

attrSaveable()[source]¶

THIS SHOULD BE OVERRIDEN BY THE IMPLEMENTER.

exportAttr(data)[source]¶

By default do nothing, but expect that this function could be overwritten

importAttr(pyld)[source]¶

By default do nothing, but expect that this function could be overwritten

loadFromDisk()[source]¶

Attempts to load the data from disk. Returns True if success, False otherwise.

saveToDisk()[source]¶

Saves the data to disk.

paradrop.lib.utils.uci module¶

class UCIConfig(filepath)[source]¶

Wrapper around the UCI configuration files.

These files are found under /etc/config/, and are used by OpenWrt to keep track of configuration for modules typically found in /etc/init.d/

The modules of interest and with current support are:

• firewall
• network
• wireless
• qos

• This class should work with any UCI module but ALL others are UNTESTED!

New configuration settings can be added to the UCI file via addConfig().

Each UCI config file is expected to contain the following syntax:

config keyA [valueA]

option key1 value1 ... list key2 value1 list key2 value2 ... list key3 value1 list key3 value2

Based on the UCI file above, the config syntax would look like the following:

config is a list of tuples, containing 2 dict objects in each tuple:

• tuple[0] describes the first line (config keyA [valueA])

  {‘type’: keyA, ‘name’: valueA} The value parameter is optional and if missing, then the ‘name’ key is also missing (rather than set to None).

• tuple[1] describes the options associated with the settings (both ‘option’ and ‘list’ lines)

  {‘key1’: ‘value1’, ...}

  If a list is present, it looks like the following:

  {

  ..., ‘list’: {

  ‘key2’: [value1, value2, ...], ‘key3’: [value1, value2, ...] }

  }

So for the example above, the full config definition would look like:

C = {‘type’: ‘keyA’, ‘name’: ‘valueA’} O = {‘key1’: ‘value1’, ‘list’: {‘key2’: [‘value1’, ‘value2’], ‘key3’: [‘value1’, ‘value2’]}} config = [(C, O)]

addConfig(config, options)[source]¶

Adds the tuple to our config.

addConfigs(configs)[source]¶

Adds a list of tuples to our config

backup(backupToken)[source]¶

Puts a backup of this config to the location specified in @backupPath.

checkWanConfig(internalid)[source]¶

delConfig(config, options)[source]¶

Finds a match to the config input and removes it from the internal config data structure.

delConfigs(configs)[source]¶

Adds a list of tuples to our config

existsConfig(config, options)[source]¶

Tests if the (config, options) is in the current config file.

getChuteConfigs(internalid)[source]¶

getConfig(config)[source]¶

Returns a list of call configs with the given title

getConfigIgnoreComments(config)[source]¶

Returns a list of call configs with the given title. Comments are ignored.

readConfig()[source]¶

Reads in the config file.

restore(backupToken, saveBackup=True)[source]¶

Replaces real file (at /etc/config/) with backup copy from /tmp/-@backupToken location.

Arguments:

backupToken: The backup token appended at the end of the backup path saveBackup : A flag to keep a backup copy or delete it (default is keep backup)

save(backupToken=None, internalid=None)[source]¶

Saves out the file in the proper format.

Arguments:

[backupPath] : Save a backup copy of the UCI file to the path provided.

Should be a token name like ‘backup’, it gets appended with a hyphen.

chuteConfigsMatch(chutePre, chutePost)[source]¶

Takes two lists of objects, and returns whether or not they are identical.

configsMatch(a, b)[source]¶

Takes 2 config objects, returns True if they match, False otherwise.

getSystemConfigDir()[source]¶

getSystemPath(filename)[source]¶

Get the path to the system configuration file.

This function also attempts to create the configuration directory if it does not exist.

Typical filenames: network, wireless, qos, firewall, dhcp, etc.

isMatch(a, b)[source]¶

isMatchIgnoreComments(a, b)[source]¶

setupArgParse()[source]¶

singleConfigMatches(a, b)[source]¶

stringify(a)[source]¶

Module contents¶