def deleteBase(datastore, name): ''' Delete a base image ''' try: # get base base = datastore.getBase(name) if base == None: raise errors.NotFoundError("Base does not exist.") # check if building and stop in case docker.stopBaseBuild(name) # delete docker image if docker.deleteBaseImage(datastore, name) == False: raise errors.ControllerError("Can't delete docker base image.") # remove from filesystem files.deleteBaseDir(name) # remove from datastore datastore.delBase(name) base['status'] = 'deleted' base['description'] = '' return base, 200 except errors.NotFoundError, e: return e.getResponse()
def deleteImage(datastore, imageToken): ''' Deletes image and stops the build process. ''' try: # get image image = datastore.getImage(imageToken) if image == None: raise errors.NotFoundError("Image does not exist.") # check if building and stop in case docker.stopBuild(image['context'], image['imageName']) # delete docker image if docker.deleteImage(datastore, imageToken) == False: raise errors.ControllerError("Can't delete docker image.") # remove from filesystem files.deleteImageDir(image['context'], image['imageName']) # remove from datastore datastore.delImage(imageToken) image['status'] = 'deleted' image['description'] = '' return image, 200 except errors.NotFoundError, e: return e.getResponse()
def deleteCluster(datastore, token): ''' Deletes the cluster and all reference with it. ''' try: # Retrieve cluster information in datastore cluster = datastore.getCluster(token) if cluster == None: raise errors.NotFoundError("Cluster does not exist.") # stop cluster (depends on the type of cluster) if cluster['type'] is 'simple-preprovisioned': pass else: raise errors.ControllerError( "Don't know how to remove a cluster of this type (" + cluster['type'] + ").") # delete folder files.deleteClusterDir(token) # delete from datastore datastore.delCluster(token) # fake cluster just to return a response cluster = {} cluster['status'] = 'deleted' cluster[ 'description'] = 'Cluster has been removed and will not be accesible anymore.' return cluster except errors.NotFoundError, e: return e.getResponse()
def newComposition(datastore, composefile, clusterReference): ''' Saves docker compose file and runs it. ''' cluster = None try: token = tokens.newCompositionToken(datastore) # retrieve cluster information from datastore cluster = datastore.getCluster(clusterReference) if cluster == None: raise errors.ControllerError("Cluster does not exist.") # Check docker endpoint = cluster['nodes'][0]['endpoint'] dk = docker.dockerClient(endpoint, settings.DK_DEFAULT_MASTER_CLIENT_CERTS) dockercheck = docker.checkDocker(dk) if dockercheck is not True: raise errors.ControllerError("Error in cluster. Docker error: " + dockercheck) # Create composition in datastore datastorecomposition = { 'token': token, 'cluster': clusterReference, 'status': 'providing', 'description': 'Providing data' } datastore.addComposition(token, datastorecomposition) # Save compose file try: files.saveComposeFile(token, composefile) except os.error: files.deleteComposeFile(token) datastore.delComposition(token) raise errors.OperationError( "Couldn't create composition in the filesystem") # Launch composition docker.runComposition(datastore, token, dk=dk) return datastorecomposition except dataStore.DataStoreError, e: aux = errors.ControllerError("Runtime error: " + e.message) return aux.getResponse()
def getDockerInfo(dockerClient): ''' Retrieve docker system information ''' try: return docker.dockerInfo(dockerClient) except Exception, e: aux = errors.ControllerError("Unknown error: " + e.message) return aux.getResponse()
def __obtainDockerHostInfo__(endpoint): # Obtain information about docker daemon listening on endpoint info = None try: dk = docker.dockerClient( base_url=endpoint, cert_path=settings.DK_DEFAULT_MASTER_CLIENT_CERTS) info = docker.dockerInfo(dk) except Exception, e: raise errors.ControllerError( "Error while connecting with provided docker host. Endpoint: '" + str(endpoint) + "' exception:" + str(e))
def getAllTokens(datastore): ''' Get all tokens in datastore ''' try: content = {} # get tokens from datastore try: content = datastore.getTokens() except: raise errors.ControllerError("Error in datastore.") return content except errors.ControllerError, e: return e.getResponse()
def newImage(datastore, contextReference, imageName, puppetmanifest=None, base=None, dockerfile=None): ''' Saves the files in the filesystem, and launch the build process ''' try: imageName=''.join(ch for ch in imageName if ch.isalnum()) token = tokens.newImageToken(datastore, contextReference, imageName) # Check if context exists and if it is completed contextInfo, statusCode = checkContext(datastore, contextReference) if statusCode == 404: raise errors.OperationError("Context does not exist") if not statusCode == 200: raise errors.OperationError("Error while inspecting context") if not contextInfo['status']=='finished': raise errors.OperationError("Context is not ready") # Create image in datastore datastoreimage = {'token':token, 'context':contextReference, 'imageName':imageName, 'status':'building', 'description':'Under creation', 'tag':datastore.getContext(contextReference)['group']+'/'+imageName.lower()} datastore.addImage(contextReference, token, datastoreimage) # Create image in filesystem and save Dockerfile and Puppetmanifest try: files.createImageDir(contextReference, imageName) if puppetmanifest!=None: files.savePuppetManifest(contextReference, imageName, puppetmanifest) if dockerfile!=None: files.saveDockerfile(contextReference, imageName, dockerfile) if base!=None: baseImageName=settings.DK_DEFAULT_BASE_PROVIDER+'/'+base if docker.imageInRegistry(baseImageName) == False: raise errors.OperationError("Base image '"+baseImageName+"' does not exist in private registry") files.createBaseDockerfile(contextReference, imageName, settings.DK_RG_ENDPOINT+'/'+baseImageName) except os.error: files.deleteImageDir(contextReference, imageName) datastore.delImage(token) raise errors.OperationError("Couldn't create image in the filesystem") # Launch build operation docker.buildImage(datastore, contextReference, imageName, token) return datastoreimage except dataStore.DataStoreError, e: aux = errors.ControllerError("Runtime error: "+ e.message) return aux.getResponse()
from toolbox import files from threading import Thread def contextList(datastore): ''' Returns a list of contexts. ''' try: listOfContexts = datastore.getContexts() return {'contexts': [] if listOfContexts == None else listOfContexts} except errors.ControllerError, e: return e.getResponse() except Exception, e: aux = errors.ControllerError("Unknown error: " + e.message) return aux.getResponse() def newContext(puppetfile, datastore, group='default'): ''' Reads and checks puppetfile, creates the directory in the filesystem and launch puppetfile processing. ''' try: token = tokens.newContextToken(datastore) # Create context in filesystem try: files.createContextDir(token) except os.error: files.deleteContextDir(token)
def __obtainDockerHostInfo__(endpoint): # Obtain information about docker daemon listening on endpoint info = None try: dk = docker.dockerClient( base_url=endpoint, cert_path=settings.DK_DEFAULT_MASTER_CLIENT_CERTS) info = docker.dockerInfo(dk) except Exception, e: raise errors.ControllerError( "Error while connecting with provided docker host. Endpoint: '" + str(endpoint) + "' exception:" + str(e)) if not info: raise errors.ControllerError( "Could not validate docker daemon on provided endpoint.") return info def newSingleProvisionedMachineCluster(datastore, endpoint, apiVersion=None): ''' Set a preprovisioned single-machine cluster. 'endpoint' is the Docker host api endpoint. ''' try: info = __obtainDockerHostInfo__(endpoint) # Generate token token = tokens.newClusterToken(datastore) # Add to filesystem: for this simple already provisioned machine, only the folder will be created
# Create composition in datastore datastorecomposition = { 'token': token, 'cluster': clusterReference, 'status': 'providing', 'description': 'Providing data' } datastore.addComposition(token, datastorecomposition) # Save compose file try: files.saveComposeFile(token, composefile) except os.error: files.deleteComposeFile(token) datastore.delComposition(token) raise errors.OperationError( "Couldn't create composition in the filesystem") # Launch composition docker.runComposition(datastore, token, dk=dk) return datastorecomposition except dataStore.DataStoreError, e: aux = errors.ControllerError("Runtime error: " + e.message) return aux.getResponse() except errors.ControllerError, e: return e.getResponse() except Exception, e: aux = errors.ControllerError("Unknown error: " + str(e)) return aux.getResponse()