Bug fixes

CyberCP/settings.py

@@ -62,6 +62,9 @@ INSTALLED_APPS = [
     'pluginHolder',
     'emailPremium',
     'emailMarketing',
+    'cloudAPI',
+    'highAvailability',
+    's3Backups',
     'dockerManager'
 ]
 

bin/activate

@@ -0,0 +1,78 @@
+# This file must be used with "source bin/activate" *from bash*
+# you cannot run it directly
+
+deactivate () {
+    unset -f pydoc >/dev/null 2>&1
+
+    # reset old environment variables
+    # ! [ -z ${VAR+_} ] returns true if VAR is declared at all
+    if ! [ -z "${_OLD_VIRTUAL_PATH+_}" ] ; then
+        PATH="$_OLD_VIRTUAL_PATH"
+        export PATH
+        unset _OLD_VIRTUAL_PATH
+    fi
+    if ! [ -z "${_OLD_VIRTUAL_PYTHONHOME+_}" ] ; then
+        PYTHONHOME="$_OLD_VIRTUAL_PYTHONHOME"
+        export PYTHONHOME
+        unset _OLD_VIRTUAL_PYTHONHOME
+    fi
+
+    # This should detect bash and zsh, which have a hash command that must
+    # be called to get it to forget past commands.  Without forgetting
+    # past commands the $PATH changes we made may not be respected
+    if [ -n "${BASH-}" ] || [ -n "${ZSH_VERSION-}" ] ; then
+        hash -r 2>/dev/null
+    fi
+
+    if ! [ -z "${_OLD_VIRTUAL_PS1+_}" ] ; then
+        PS1="$_OLD_VIRTUAL_PS1"
+        export PS1
+        unset _OLD_VIRTUAL_PS1
+    fi
+
+    unset VIRTUAL_ENV
+    if [ ! "${1-}" = "nondestructive" ] ; then
+    # Self destruct!
+        unset -f deactivate
+    fi
+}
+
+# unset irrelevant variables
+deactivate nondestructive
+
+VIRTUAL_ENV="/usr/local/CyberCP"
+export VIRTUAL_ENV
+
+_OLD_VIRTUAL_PATH="$PATH"
+PATH="$VIRTUAL_ENV/bin:$PATH"
+export PATH
+
+# unset PYTHONHOME if set
+if ! [ -z "${PYTHONHOME+_}" ] ; then
+    _OLD_VIRTUAL_PYTHONHOME="$PYTHONHOME"
+    unset PYTHONHOME
+fi
+
+if [ -z "${VIRTUAL_ENV_DISABLE_PROMPT-}" ] ; then
+    _OLD_VIRTUAL_PS1="$PS1"
+    if [ "x" != x ] ; then
+        PS1="$PS1"
+    else
+        PS1="(`basename \"$VIRTUAL_ENV\"`) $PS1"
+    fi
+    export PS1
+fi
+
+# Make sure to unalias pydoc if it's already there
+alias pydoc 2>/dev/null >/dev/null && unalias pydoc
+
+pydoc () {
+    python -m pydoc "$@"
+}
+
+# This should detect bash and zsh, which have a hash command that must
+# be called to get it to forget past commands.  Without forgetting
+# past commands the $PATH changes we made may not be respected
+if [ -n "${BASH-}" ] || [ -n "${ZSH_VERSION-}" ] ; then
+    hash -r 2>/dev/null
+fi

bin/activate.csh

@@ -0,0 +1,42 @@
+# This file must be used with "source bin/activate.csh" *from csh*.
+# You cannot run it directly.
+# Created by Davide Di Blasi <davidedb@gmail.com>.
+
+set newline='\
+'
+
+alias deactivate 'test $?_OLD_VIRTUAL_PATH != 0 && setenv PATH "$_OLD_VIRTUAL_PATH:q" && unset _OLD_VIRTUAL_PATH; rehash; test $?_OLD_VIRTUAL_PROMPT != 0 && set prompt="$_OLD_VIRTUAL_PROMPT:q" && unset _OLD_VIRTUAL_PROMPT; unsetenv VIRTUAL_ENV; test "\!:*" != "nondestructive" && unalias deactivate && unalias pydoc'
+
+# Unset irrelevant variables.
+deactivate nondestructive
+
+setenv VIRTUAL_ENV "/usr/local/CyberCP"
+
+set _OLD_VIRTUAL_PATH="$PATH:q"
+setenv PATH "$VIRTUAL_ENV:q/bin:$PATH:q"
+
+
+
+if ("" != "") then
+    set env_name = ""
+else
+    set env_name = "$VIRTUAL_ENV:t:q"
+endif
+
+# Could be in a non-interactive environment,
+# in which case, $prompt is undefined and we wouldn't
+# care about the prompt anyway.
+if ( $?prompt ) then
+    set _OLD_VIRTUAL_PROMPT="$prompt:q"
+if ( "$prompt:q" =~ *"$newline:q"* ) then
+    :
+else
+    set prompt = "[$env_name:q] $prompt:q"
+endif
+endif
+
+unset env_name
+
+alias pydoc python -m pydoc
+
+rehash

bin/activate.fish

@@ -0,0 +1,76 @@
+# This file must be used using `source bin/activate.fish` *within a running fish ( http://fishshell.com ) session*.
+# Do not run it directly.
+
+function deactivate -d 'Exit virtualenv mode and return to the normal environment.'
+    # reset old environment variables
+    if test -n "$_OLD_VIRTUAL_PATH"
+        set -gx PATH $_OLD_VIRTUAL_PATH
+        set -e _OLD_VIRTUAL_PATH
+    end
+
+    if test -n "$_OLD_VIRTUAL_PYTHONHOME"
+        set -gx PYTHONHOME $_OLD_VIRTUAL_PYTHONHOME
+        set -e _OLD_VIRTUAL_PYTHONHOME
+    end
+
+    if test -n "$_OLD_FISH_PROMPT_OVERRIDE"
+        # Set an empty local `$fish_function_path` to allow the removal of `fish_prompt` using `functions -e`.
+        set -l fish_function_path
+
+        # Erase virtualenv's `fish_prompt` and restore the original.
+        functions -e fish_prompt
+        functions -c _old_fish_prompt fish_prompt
+        functions -e _old_fish_prompt
+        set -e _OLD_FISH_PROMPT_OVERRIDE
+    end
+
+    set -e VIRTUAL_ENV
+
+    if test "$argv[1]" != 'nondestructive'
+        # Self-destruct!
+        functions -e pydoc
+        functions -e deactivate
+    end
+end
+
+# Unset irrelevant variables.
+deactivate nondestructive
+
+set -gx VIRTUAL_ENV "/usr/local/CyberCP"
+
+set -gx _OLD_VIRTUAL_PATH $PATH
+set -gx PATH "$VIRTUAL_ENV/bin" $PATH
+
+# Unset `$PYTHONHOME` if set.
+if set -q PYTHONHOME
+    set -gx _OLD_VIRTUAL_PYTHONHOME $PYTHONHOME
+    set -e PYTHONHOME
+end
+
+function pydoc
+    python -m pydoc $argv
+end
+
+if test -z "$VIRTUAL_ENV_DISABLE_PROMPT"
+    # Copy the current `fish_prompt` function as `_old_fish_prompt`.
+    functions -c fish_prompt _old_fish_prompt
+
+    function fish_prompt
+        # Save the current $status, for fish_prompts that display it.
+        set -l old_status $status
+
+        # Prompt override provided?
+        # If not, just prepend the environment name.
+        if test -n ""
+            printf '%s%s' "" (set_color normal)
+        else
+            printf '%s(%s) ' (set_color normal) (basename "$VIRTUAL_ENV")
+        end
+
+        # Restore the original $status
+        echo "exit $old_status" | source
+        _old_fish_prompt
+    end
+
+    set -gx _OLD_FISH_PROMPT_OVERRIDE "$VIRTUAL_ENV"
+end

bin/activate.ps1

@@ -0,0 +1,150 @@
+# This file must be dot sourced from PoSh; you cannot run it
+# directly. Do this: . ./activate.ps1
+
+# FIXME: clean up unused vars.
+$script:THIS_PATH = $myinvocation.mycommand.path
+$script:BASE_DIR = split-path (resolve-path "$THIS_PATH/..") -Parent
+$script:DIR_NAME = split-path $BASE_DIR -Leaf
+
+function global:deactivate ( [switch] $NonDestructive ){
+
+    if ( test-path variable:_OLD_VIRTUAL_PATH ) {
+        $env:PATH = $variable:_OLD_VIRTUAL_PATH
+        remove-variable "_OLD_VIRTUAL_PATH" -scope global
+    }
+
+    if ( test-path function:_old_virtual_prompt ) {
+        $function:prompt = $function:_old_virtual_prompt
+        remove-item function:\_old_virtual_prompt
+    }
+
+    if ($env:VIRTUAL_ENV) {
+        $old_env = split-path $env:VIRTUAL_ENV -leaf
+        remove-item env:VIRTUAL_ENV -erroraction silentlycontinue
+    }
+
+    if ( !$NonDestructive ) {
+        # Self destruct!
+        remove-item function:deactivate
+    }
+}
+
+# unset irrelevant variables
+deactivate -nondestructive
+
+$VIRTUAL_ENV = $BASE_DIR
+$env:VIRTUAL_ENV = $VIRTUAL_ENV
+
+$global:_OLD_VIRTUAL_PATH = $env:PATH
+$env:PATH = "$env:VIRTUAL_ENV/bin:" + $env:PATH
+if (! $env:VIRTUAL_ENV_DISABLE_PROMPT) {
+    function global:_old_virtual_prompt { "" }
+    $function:_old_virtual_prompt = $function:prompt
+    function global:prompt {
+        # Add a prefix to the current prompt, but don't discard it.
+        write-host "($(split-path $env:VIRTUAL_ENV -leaf)) " -nonewline
+        & $function:_old_virtual_prompt
+    }
+}
+
+# SIG # Begin signature block
+# MIISeAYJKoZIhvcNAQcCoIISaTCCEmUCAQExCzAJBgUrDgMCGgUAMGkGCisGAQQB
+# gjcCAQSgWzBZMDQGCisGAQQBgjcCAR4wJgIDAQAABBAfzDtgWUsITrck0sYpfvNR
+# AgEAAgEAAgEAAgEAAgEAMCEwCQYFKw4DAhoFAAQUS5reBwSg3zOUwhXf2jPChZzf
+# yPmggg6tMIIGcDCCBFigAwIBAgIBJDANBgkqhkiG9w0BAQUFADB9MQswCQYDVQQG
+# EwJJTDEWMBQGA1UEChMNU3RhcnRDb20gTHRkLjErMCkGA1UECxMiU2VjdXJlIERp
+# Z2l0YWwgQ2VydGlmaWNhdGUgU2lnbmluZzEpMCcGA1UEAxMgU3RhcnRDb20gQ2Vy
+# dGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDcxMDI0MjIwMTQ2WhcNMTcxMDI0MjIw
+# MTQ2WjCBjDELMAkGA1UEBhMCSUwxFjAUBgNVBAoTDVN0YXJ0Q29tIEx0ZC4xKzAp
+# BgNVBAsTIlNlY3VyZSBEaWdpdGFsIENlcnRpZmljYXRlIFNpZ25pbmcxODA2BgNV
+# BAMTL1N0YXJ0Q29tIENsYXNzIDIgUHJpbWFyeSBJbnRlcm1lZGlhdGUgT2JqZWN0
+# IENBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAyiOLIjUemqAbPJ1J
+# 0D8MlzgWKbr4fYlbRVjvhHDtfhFN6RQxq0PjTQxRgWzwFQNKJCdU5ftKoM5N4YSj
+# Id6ZNavcSa6/McVnhDAQm+8H3HWoD030NVOxbjgD/Ih3HaV3/z9159nnvyxQEckR
+# ZfpJB2Kfk6aHqW3JnSvRe+XVZSufDVCe/vtxGSEwKCaNrsLc9pboUoYIC3oyzWoU
+# TZ65+c0H4paR8c8eK/mC914mBo6N0dQ512/bkSdaeY9YaQpGtW/h/W/FkbQRT3sC
+# pttLVlIjnkuY4r9+zvqhToPjxcfDYEf+XD8VGkAqle8Aa8hQ+M1qGdQjAye8OzbV
+# uUOw7wIDAQABo4IB6TCCAeUwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMC
+# AQYwHQYDVR0OBBYEFNBOD0CZbLhLGW87KLjg44gHNKq3MB8GA1UdIwQYMBaAFE4L
+# 7xqkQFulF2mHMMo0aEPQQa7yMD0GCCsGAQUFBwEBBDEwLzAtBggrBgEFBQcwAoYh
+# aHR0cDovL3d3dy5zdGFydHNzbC5jb20vc2ZzY2EuY3J0MFsGA1UdHwRUMFIwJ6Al
+# oCOGIWh0dHA6Ly93d3cuc3RhcnRzc2wuY29tL3Nmc2NhLmNybDAnoCWgI4YhaHR0
+# cDovL2NybC5zdGFydHNzbC5jb20vc2ZzY2EuY3JsMIGABgNVHSAEeTB3MHUGCysG
+# AQQBgbU3AQIBMGYwLgYIKwYBBQUHAgEWImh0dHA6Ly93d3cuc3RhcnRzc2wuY29t
+# L3BvbGljeS5wZGYwNAYIKwYBBQUHAgEWKGh0dHA6Ly93d3cuc3RhcnRzc2wuY29t
+# L2ludGVybWVkaWF0ZS5wZGYwEQYJYIZIAYb4QgEBBAQDAgABMFAGCWCGSAGG+EIB
+# DQRDFkFTdGFydENvbSBDbGFzcyAyIFByaW1hcnkgSW50ZXJtZWRpYXRlIE9iamVj
+# dCBTaWduaW5nIENlcnRpZmljYXRlczANBgkqhkiG9w0BAQUFAAOCAgEAcnMLA3Va
+# N4OIE9l4QT5OEtZy5PByBit3oHiqQpgVEQo7DHRsjXD5H/IyTivpMikaaeRxIv95
+# baRd4hoUcMwDj4JIjC3WA9FoNFV31SMljEZa66G8RQECdMSSufgfDYu1XQ+cUKxh
+# D3EtLGGcFGjjML7EQv2Iol741rEsycXwIXcryxeiMbU2TPi7X3elbwQMc4JFlJ4B
+# y9FhBzuZB1DV2sN2irGVbC3G/1+S2doPDjL1CaElwRa/T0qkq2vvPxUgryAoCppU
+# FKViw5yoGYC+z1GaesWWiP1eFKAL0wI7IgSvLzU3y1Vp7vsYaxOVBqZtebFTWRHt
+# XjCsFrrQBngt0d33QbQRI5mwgzEp7XJ9xu5d6RVWM4TPRUsd+DDZpBHm9mszvi9g
+# VFb2ZG7qRRXCSqys4+u/NLBPbXi/m/lU00cODQTlC/euwjk9HQtRrXQ/zqsBJS6U
+# J+eLGw1qOfj+HVBl/ZQpfoLk7IoWlRQvRL1s7oirEaqPZUIWY/grXq9r6jDKAp3L
+# ZdKQpPOnnogtqlU4f7/kLjEJhrrc98mrOWmVMK/BuFRAfQ5oDUMnVmCzAzLMjKfG
+# cVW/iMew41yfhgKbwpfzm3LBr1Zv+pEBgcgW6onRLSAn3XHM0eNtz+AkxH6rRf6B
+# 2mYhLEEGLapH8R1AMAo4BbVFOZR5kXcMCwowggg1MIIHHaADAgECAgIEuDANBgkq
+# hkiG9w0BAQUFADCBjDELMAkGA1UEBhMCSUwxFjAUBgNVBAoTDVN0YXJ0Q29tIEx0
+# ZC4xKzApBgNVBAsTIlNlY3VyZSBEaWdpdGFsIENlcnRpZmljYXRlIFNpZ25pbmcx
+# ODA2BgNVBAMTL1N0YXJ0Q29tIENsYXNzIDIgUHJpbWFyeSBJbnRlcm1lZGlhdGUg
+# T2JqZWN0IENBMB4XDTExMTIwMzE1MzQxOVoXDTEzMTIwMzE0NTgwN1owgYwxIDAe
+# BgNVBA0TFzU4MTc5Ni1HaDd4Zkp4a3hRU0lPNEUwMQswCQYDVQQGEwJERTEPMA0G
+# A1UECBMGQmVybGluMQ8wDQYDVQQHEwZCZXJsaW4xFjAUBgNVBAMTDUphbm5pcyBM
+# ZWlkZWwxITAfBgkqhkiG9w0BCQEWEmphbm5pc0BsZWlkZWwuaW5mbzCCAiIwDQYJ
+# KoZIhvcNAQEBBQADggIPADCCAgoCggIBAMcPeABYdN7nPq/AkZ/EkyUBGx/l2Yui
+# Lfm8ZdLG0ulMb/kQL3fRY7sUjYPyn9S6PhqqlFnNoGHJvbbReCdUC9SIQYmOEjEA
+# raHfb7MZU10NjO4U2DdGucj2zuO5tYxKizizOJF0e4yRQZVxpUGdvkW/+GLjCNK5
+# L7mIv3Z1dagxDKHYZT74HXiS4VFUwHF1k36CwfM2vsetdm46bdgSwV+BCMmZICYT
+# IJAS9UQHD7kP4rik3bFWjUx08NtYYFAVOd/HwBnemUmJe4j3IhZHr0k1+eDG8hDH
+# KVvPgLJIoEjC4iMFk5GWsg5z2ngk0LLu3JZMtckHsnnmBPHQK8a3opUNd8hdMNJx
+# gOwKjQt2JZSGUdIEFCKVDqj0FmdnDMPfwy+FNRtpBMl1sz78dUFhSrnM0D8NXrqa
+# 4rG+2FoOXlmm1rb6AFtpjAKksHRpYcPk2DPGWp/1sWB+dUQkS3gOmwFzyqeTuXpT
+# 0juqd3iAxOGx1VRFQ1VHLLf3AzV4wljBau26I+tu7iXxesVucSdsdQu293jwc2kN
+# xK2JyHCoZH+RyytrwS0qw8t7rMOukU9gwP8mn3X6mgWlVUODMcHTULjSiCEtvyZ/
+# aafcwjUbt4ReEcnmuZtWIha86MTCX7U7e+cnpWG4sIHPnvVTaz9rm8RyBkIxtFCB
+# nQ3FnoQgyxeJAgMBAAGjggOdMIIDmTAJBgNVHRMEAjAAMA4GA1UdDwEB/wQEAwIH
+# gDAuBgNVHSUBAf8EJDAiBggrBgEFBQcDAwYKKwYBBAGCNwIBFQYKKwYBBAGCNwoD
+# DTAdBgNVHQ4EFgQUWyCgrIWo8Ifvvm1/YTQIeMU9nc8wHwYDVR0jBBgwFoAU0E4P
+# QJlsuEsZbzsouODjiAc0qrcwggIhBgNVHSAEggIYMIICFDCCAhAGCysGAQQBgbU3
+# AQICMIIB/zAuBggrBgEFBQcCARYiaHR0cDovL3d3dy5zdGFydHNzbC5jb20vcG9s
+# aWN5LnBkZjA0BggrBgEFBQcCARYoaHR0cDovL3d3dy5zdGFydHNzbC5jb20vaW50
+# ZXJtZWRpYXRlLnBkZjCB9wYIKwYBBQUHAgIwgeowJxYgU3RhcnRDb20gQ2VydGlm
+# aWNhdGlvbiBBdXRob3JpdHkwAwIBARqBvlRoaXMgY2VydGlmaWNhdGUgd2FzIGlz
+# c3VlZCBhY2NvcmRpbmcgdG8gdGhlIENsYXNzIDIgVmFsaWRhdGlvbiByZXF1aXJl
+# bWVudHMgb2YgdGhlIFN0YXJ0Q29tIENBIHBvbGljeSwgcmVsaWFuY2Ugb25seSBm
+# b3IgdGhlIGludGVuZGVkIHB1cnBvc2UgaW4gY29tcGxpYW5jZSBvZiB0aGUgcmVs
+# eWluZyBwYXJ0eSBvYmxpZ2F0aW9ucy4wgZwGCCsGAQUFBwICMIGPMCcWIFN0YXJ0
+# Q29tIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MAMCAQIaZExpYWJpbGl0eSBhbmQg
+# d2FycmFudGllcyBhcmUgbGltaXRlZCEgU2VlIHNlY3Rpb24gIkxlZ2FsIGFuZCBM
+# aW1pdGF0aW9ucyIgb2YgdGhlIFN0YXJ0Q29tIENBIHBvbGljeS4wNgYDVR0fBC8w
+# LTAroCmgJ4YlaHR0cDovL2NybC5zdGFydHNzbC5jb20vY3J0YzItY3JsLmNybDCB
+# iQYIKwYBBQUHAQEEfTB7MDcGCCsGAQUFBzABhitodHRwOi8vb2NzcC5zdGFydHNz
+# bC5jb20vc3ViL2NsYXNzMi9jb2RlL2NhMEAGCCsGAQUFBzAChjRodHRwOi8vYWlh
+# LnN0YXJ0c3NsLmNvbS9jZXJ0cy9zdWIuY2xhc3MyLmNvZGUuY2EuY3J0MCMGA1Ud
+# EgQcMBqGGGh0dHA6Ly93d3cuc3RhcnRzc2wuY29tLzANBgkqhkiG9w0BAQUFAAOC
+# AQEAhrzEV6zwoEtKjnFRhCsjwiPykVpo5Eiye77Ve801rQDiRKgSCCiW6g3HqedL
+# OtaSs65Sj2pm3Viea4KR0TECLcbCTgsdaHqw2x1yXwWBQWZEaV6EB05lIwfr94P1
+# SFpV43zkuc+bbmA3+CRK45LOcCNH5Tqq7VGTCAK5iM7tvHwFlbQRl+I6VEL2mjpF
+# NsuRjDOVrv/9qw/a22YJ9R7Y1D0vUSs3IqZx2KMUaYDP7H2mSRxJO2nADQZBtriF
+# gTyfD3lYV12MlIi5CQwe3QC6DrrfSMP33i5Wa/OFJiQ27WPxmScYVhiqozpImFT4
+# PU9goiBv9RKXdgTmZE1PN0NQ5jGCAzUwggMxAgEBMIGTMIGMMQswCQYDVQQGEwJJ
+# TDEWMBQGA1UEChMNU3RhcnRDb20gTHRkLjErMCkGA1UECxMiU2VjdXJlIERpZ2l0
+# YWwgQ2VydGlmaWNhdGUgU2lnbmluZzE4MDYGA1UEAxMvU3RhcnRDb20gQ2xhc3Mg
+# MiBQcmltYXJ5IEludGVybWVkaWF0ZSBPYmplY3QgQ0ECAgS4MAkGBSsOAwIaBQCg
+# eDAYBgorBgEEAYI3AgEMMQowCKACgAChAoAAMBkGCSqGSIb3DQEJAzEMBgorBgEE
+# AYI3AgEEMBwGCisGAQQBgjcCAQsxDjAMBgorBgEEAYI3AgEVMCMGCSqGSIb3DQEJ
+# BDEWBBRVGw0FDSiaIi38dWteRUAg/9Pr6DANBgkqhkiG9w0BAQEFAASCAgCInvOZ
+# FdaNFzbf6trmFDZKMojyx3UjKMCqNjHVBbuKY0qXwFC/ElYDV1ShJ2CBZbdurydO
+# OQ6cIQ0KREOCwmX/xB49IlLHHUxNhEkVv7HGU3EKAFf9IBt9Yr7jikiR9cjIsfHK
+# 4cjkoKJL7g28yEpLLkHt1eo37f1Ga9lDWEa5Zq3U5yX+IwXhrUBm1h8Xr033FhTR
+# VEpuSz6LHtbrL/zgJnCzJ2ahjtJoYevdcWiNXffosJHFaSfYDDbiNsPRDH/1avmb
+# 5j/7BhP8BcBaR6Fp8tFbNGIcWHHGcjqLMnTc4w13b7b4pDhypqElBa4+lCmwdvv9
+# GydYtRgPz8GHeoBoKj30YBlMzRIfFYaIFGIC4Ai3UEXkuH9TxYohVbGm/W0Kl4Lb
+# RJ1FwiVcLcTOJdgNId2vQvKc+jtNrjcg5SP9h2v/C4aTx8tyc6tE3TOPh2f9b8DL
+# S+SbVArJpuJqrPTxDDoO1QNjTgLcdVYeZDE+r/NjaGZ6cMSd8db3EaG3ijD/0bud
+# SItbm/OlNVbQOFRR76D+ZNgPcU5iNZ3bmvQQIg6aSB9MHUpIE/SeCkNl9YeVk1/1
+# GFULgNMRmIYP4KLvu9ylh5Gu3hvD5VNhH6+FlXANwFy07uXks5uF8mfZVxVCnodG
+# xkNCx+6PsrA5Z7WP4pXcmYnMn97npP/Q9EHJWw==
+# SIG # End signature block

bin/activate_this.py

@@ -0,0 +1,36 @@
+"""By using execfile(this_file, dict(__file__=this_file)) you will
+activate this virtualenv environment.
+
+This can be used when you must use an existing Python interpreter, not
+the virtualenv bin/python
+"""
+
+try:
+    __file__
+except NameError:
+    raise AssertionError(
+        "You must run this like execfile('path/to/activate_this.py', dict(__file__='path/to/activate_this.py'))"
+    )
+import os
+import site
+import sys
+
+old_os_path = os.environ.get("PATH", "")
+os.environ["PATH"] = os.path.dirname(os.path.abspath(__file__)) + os.pathsep + old_os_path
+base = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+if sys.platform == "win32":
+    site_packages = os.path.join(base, "Lib", "site-packages")
+else:
+    site_packages = os.path.join(base, "lib", "python%s" % sys.version[:3], "site-packages")
+prev_sys_path = list(sys.path)
+
+site.addsitedir(site_packages)
+sys.real_prefix = sys.prefix
+sys.prefix = base
+# Move the added items to the front of the path:
+new_sys_path = []
+for item in list(sys.path):
+    if item not in prev_sys_path:
+        new_sys_path.append(item)
+        sys.path.remove(item)
+sys.path[:0] = new_sys_path

bin/certbot

@@ -0,0 +1,11 @@
+#!/usr/local/CyberCP/bin/python2
+
+# -*- coding: utf-8 -*-
+import re
+import sys
+
+from certbot.main import main
+
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

bin/chardetect

@@ -0,0 +1,11 @@
+#!/usr/local/CyberCP/bin/python2
+
+# -*- coding: utf-8 -*-
+import re
+import sys
+
+from chardet.cli.chardetect import main
+
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

bin/django-admin

@@ -0,0 +1,11 @@
+#!/usr/local/CyberCP/bin/python2
+
+# -*- coding: utf-8 -*-
+import re
+import sys
+
+from django.core.management import execute_from_command_line
+
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
+    sys.exit(execute_from_command_line())

bin/django-admin.py

@@ -0,0 +1,5 @@
+#!/usr/local/CyberCP/bin/python2
+from django.core import management
+
+if __name__ == "__main__":
+    management.execute_from_command_line()

bin/easy_install

@@ -0,0 +1,11 @@
+#!/usr/local/CyberCP/bin/python2
+
+# -*- coding: utf-8 -*-
+import re
+import sys
+
+from setuptools.command.easy_install import main
+
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

bin/easy_install-2.7

@@ -0,0 +1,11 @@
+#!/usr/local/CyberCP/bin/python2
+
+# -*- coding: utf-8 -*-
+import re
+import sys
+
+from setuptools.command.easy_install import main
+
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

bin/futurize

@@ -0,0 +1,11 @@
+#!/usr/local/CyberCP/bin/python2
+
+# -*- coding: utf-8 -*-
+import re
+import sys
+
+from libfuturize.main import main
+
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

bin/gunicorn

@@ -0,0 +1,11 @@
+#!/usr/local/CyberCP/bin/python2
+
+# -*- coding: utf-8 -*-
+import re
+import sys
+
+from gunicorn.app.wsgiapp import run
+
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
+    sys.exit(run())

bin/gunicorn_paster

@@ -0,0 +1,11 @@
+#!/usr/local/CyberCP/bin/python2
+
+# -*- coding: utf-8 -*-
+import re
+import sys
+
+from gunicorn.app.pasterapp import run
+
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
+    sys.exit(run())

bin/jsonpointer

@@ -0,0 +1,46 @@
+#!/home/stefan/work/python-json-patch/venv/bin/python
+# -*- coding: utf-8 -*-
+
+from __future__ import print_function
+
+import sys
+import os.path
+import json
+import jsonpointer
+import argparse
+
+
+parser = argparse.ArgumentParser(
+    description='Resolve a JSON pointer on JSON files')
+parser.add_argument('POINTER', type=argparse.FileType('r'),
+                    help='File containing a JSON pointer expression')
+parser.add_argument('FILE', type=argparse.FileType('r'), nargs='+',
+                    help='Files for which the pointer should be resolved')
+parser.add_argument('--indent', type=int, default=None,
+                    help='Indent output by n spaces')
+parser.add_argument('-v', '--version', action='version',
+                    version='%(prog)s ' + jsonpointer.__version__)
+
+
+def main():
+    try:
+        resolve_files()
+    except KeyboardInterrupt:
+        sys.exit(1)
+
+
+def resolve_files():
+    """ Resolve a JSON pointer on JSON files """
+    args = parser.parse_args()
+    ptr = json.load(args.POINTER)
+    for f in args.FILE:
+        doc = json.load(f)
+        try:
+            result = jsonpointer.resolve_pointer(doc, ptr)
+            print(json.dumps(result, indent=args.indent))
+        except jsonpointer.JsonPointerException as e:
+            print('Could not resolve pointer: %s' % str(e), file=sys.stderr)
+
+
+if __name__ == "__main__":
+    main()

bin/jws

@@ -0,0 +1,11 @@
+#!/usr/local/CyberCP/bin/python2
+
+# -*- coding: utf-8 -*-
+import re
+import sys
+
+from josepy.jws import CLI
+
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
+    sys.exit(CLI.run())

bin/miniterm.py

@@ -0,0 +1,645 @@
+#!/usr/local/CyberCP/bin/python2
+
+# Very simple serial terminal
+# (C)2002-2011 Chris Liechti <cliechti@gmx.net>
+
+# Input characters are sent directly (only LF -> CR/LF/CRLF translation is
+# done), received characters are displayed as is (or escaped trough pythons
+# repr, useful for debug purposes)
+
+
+import sys, os, serial, threading
+
+EXITCHARCTER = '\x1d'   # GS/CTRL+]
+MENUCHARACTER = '\x14'  # Menu: CTRL+T
+
+
+def key_description(character):
+    """generate a readable description for a key"""
+    ascii_code = ord(character)
+    if ascii_code < 32:
+        return 'Ctrl+%c' % (ord('@') + ascii_code)
+    else:
+        return repr(character)
+
+
+# help text, starts with blank line! it's a function so that the current values
+# for the shortcut keys is used and not the value at program start
+def get_help_text():
+    return """
+--- pySerial (%(version)s) - miniterm - help
+---
+--- %(exit)-8s Exit program
+--- %(menu)-8s Menu escape key, followed by:
+--- Menu keys:
+---    %(itself)-7s Send the menu character itself to remote
+---    %(exchar)-7s Send the exit character itself to remote
+---    %(info)-7s Show info
+---    %(upload)-7s Upload file (prompt will be shown)
+--- Toggles:
+---    %(rts)-7s RTS          %(echo)-7s local echo
+---    %(dtr)-7s DTR          %(break)-7s BREAK
+---    %(lfm)-7s line feed    %(repr)-7s Cycle repr mode
+---
+--- Port settings (%(menu)s followed by the following):
+---    p          change port
+---    7 8        set data bits
+---    n e o s m  change parity (None, Even, Odd, Space, Mark)
+---    1 2 3      set stop bits (1, 2, 1.5)
+---    b          change baud rate
+---    x X        disable/enable software flow control
+---    r R        disable/enable hardware flow control
+""" % {
+    'version': getattr(serial, 'VERSION', 'unknown version'),
+    'exit': key_description(EXITCHARCTER),
+    'menu': key_description(MENUCHARACTER),
+    'rts': key_description('\x12'),
+    'repr': key_description('\x01'),
+    'dtr': key_description('\x04'),
+    'lfm': key_description('\x0c'),
+    'break': key_description('\x02'),
+    'echo': key_description('\x05'),
+    'info': key_description('\x09'),
+    'upload': key_description('\x15'),
+    'itself': key_description(MENUCHARACTER),
+    'exchar': key_description(EXITCHARCTER),
+}
+
+if sys.version_info >= (3, 0):
+    def character(b):
+        return b.decode('latin1')
+else:
+    def character(b):
+        return b
+
+# first choose a platform dependant way to read single characters from the console
+global console
+
+if os.name == 'nt':
+    import msvcrt
+    class Console(object):
+        def __init__(self):
+            pass
+
+        def setup(self):
+            pass    # Do nothing for 'nt'
+
+        def cleanup(self):
+            pass    # Do nothing for 'nt'
+
+        def getkey(self):
+            while True:
+                z = msvcrt.getch()
+                if z == '\0' or z == '\xe0':    # functions keys, ignore
+                    msvcrt.getch()
+                else:
+                    if z == '\r':
+                        return '\n'
+                    return z
+
+    console = Console()
+
+elif os.name == 'posix':
+    import termios, sys, os
+    class Console(object):
+        def __init__(self):
+            self.fd = sys.stdin.fileno()
+
+        def setup(self):
+            self.old = termios.tcgetattr(self.fd)
+            new = termios.tcgetattr(self.fd)
+            new[3] = new[3] & ~termios.ICANON & ~termios.ECHO & ~termios.ISIG
+            new[6][termios.VMIN] = 1
+            new[6][termios.VTIME] = 0
+            termios.tcsetattr(self.fd, termios.TCSANOW, new)
+
+        def getkey(self):
+            c = os.read(self.fd, 1)
+            return c
+
+        def cleanup(self):
+            termios.tcsetattr(self.fd, termios.TCSAFLUSH, self.old)
+
+    console = Console()
+
+    def cleanup_console():
+        console.cleanup()
+
+    console.setup()
+    sys.exitfunc = cleanup_console      # terminal modes have to be restored on exit...
+
+else:
+    raise NotImplementedError("Sorry no implementation for your platform (%s) available." % sys.platform)
+
+
+CONVERT_CRLF = 2
+CONVERT_CR   = 1
+CONVERT_LF   = 0
+NEWLINE_CONVERISON_MAP = ('\n', '\r', '\r\n')
+LF_MODES = ('LF', 'CR', 'CR/LF')
+
+REPR_MODES = ('raw', 'some control', 'all control', 'hex')
+
+class Miniterm(object):
+    def __init__(self, port, baudrate, parity, rtscts, xonxoff, echo=False, convert_outgoing=CONVERT_CRLF, repr_mode=0):
+        try:
+            self.serial = serial.serial_for_url(port, baudrate, parity=parity, rtscts=rtscts, xonxoff=xonxoff, timeout=1)
+        except AttributeError:
+            # happens when the installed pyserial is older than 2.5. use the
+            # Serial class directly then.
+            self.serial = serial.Serial(port, baudrate, parity=parity, rtscts=rtscts, xonxoff=xonxoff, timeout=1)
+        self.echo = echo
+        self.repr_mode = repr_mode
+        self.convert_outgoing = convert_outgoing
+        self.newline = NEWLINE_CONVERISON_MAP[self.convert_outgoing]
+        self.dtr_state = True
+        self.rts_state = True
+        self.break_state = False
+
+    def _start_reader(self):
+        """Start reader thread"""
+        self._reader_alive = True
+        # start serial->console thread
+        self.receiver_thread = threading.Thread(target=self.reader)
+        self.receiver_thread.setDaemon(True)
+        self.receiver_thread.start()
+
+    def _stop_reader(self):
+        """Stop reader thread only, wait for clean exit of thread"""
+        self._reader_alive = False
+        self.receiver_thread.join()
+
+
+    def start(self):
+        self.alive = True
+        self._start_reader()
+        # enter console->serial loop
+        self.transmitter_thread = threading.Thread(target=self.writer)
+        self.transmitter_thread.setDaemon(True)
+        self.transmitter_thread.start()
+
+    def stop(self):
+        self.alive = False
+
+    def join(self, transmit_only=False):
+        self.transmitter_thread.join()
+        if not transmit_only:
+            self.receiver_thread.join()
+
+    def dump_port_settings(self):
+        sys.stderr.write("\n--- Settings: %s  %s,%s,%s,%s\n" % (
+                self.serial.portstr,
+                self.serial.baudrate,
+                self.serial.bytesize,
+                self.serial.parity,
+                self.serial.stopbits))
+        sys.stderr.write('--- RTS: %-8s  DTR: %-8s  BREAK: %-8s\n' % (
+                (self.rts_state and 'active' or 'inactive'),
+                (self.dtr_state and 'active' or 'inactive'),
+                (self.break_state and 'active' or 'inactive')))
+        try:
+            sys.stderr.write('--- CTS: %-8s  DSR: %-8s  RI: %-8s  CD: %-8s\n' % (
+                    (self.serial.getCTS() and 'active' or 'inactive'),
+                    (self.serial.getDSR() and 'active' or 'inactive'),
+                    (self.serial.getRI() and 'active' or 'inactive'),
+                    (self.serial.getCD() and 'active' or 'inactive')))
+        except serial.SerialException:
+            # on RFC 2217 ports it can happen to no modem state notification was
+            # yet received. ignore this error.
+            pass
+        sys.stderr.write('--- software flow control: %s\n' % (self.serial.xonxoff and 'active' or 'inactive'))
+        sys.stderr.write('--- hardware flow control: %s\n' % (self.serial.rtscts and 'active' or 'inactive'))
+        sys.stderr.write('--- data escaping: %s  linefeed: %s\n' % (
+                REPR_MODES[self.repr_mode],
+                LF_MODES[self.convert_outgoing]))
+
+    def reader(self):
+        """loop and copy serial->console"""
+        try:
+            while self.alive and self._reader_alive:
+                data = character(self.serial.read(1))
+
+                if self.repr_mode == 0:
+                    # direct output, just have to care about newline setting
+                    if data == '\r' and self.convert_outgoing == CONVERT_CR:
+                        sys.stdout.write('\n')
+                    else:
+                        sys.stdout.write(data)
+                elif self.repr_mode == 1:
+                    # escape non-printable, let pass newlines
+                    if self.convert_outgoing == CONVERT_CRLF and data in '\r\n':
+                        if data == '\n':
+                            sys.stdout.write('\n')
+                        elif data == '\r':
+                            pass
+                    elif data == '\n' and self.convert_outgoing == CONVERT_LF:
+                        sys.stdout.write('\n')
+                    elif data == '\r' and self.convert_outgoing == CONVERT_CR:
+                        sys.stdout.write('\n')
+                    else:
+                        sys.stdout.write(repr(data)[1:-1])
+                elif self.repr_mode == 2:
+                    # escape all non-printable, including newline
+                    sys.stdout.write(repr(data)[1:-1])
+                elif self.repr_mode == 3:
+                    # escape everything (hexdump)
+                    for c in data:
+                        sys.stdout.write("%s " % c.encode('hex'))
+                sys.stdout.flush()
+        except serial.SerialException, e:
+            self.alive = False
+            # would be nice if the console reader could be interruptted at this
+            # point...
+            raise
+
+
+    def writer(self):
+        """\
+        Loop and copy console->serial until EXITCHARCTER character is
+        found. When MENUCHARACTER is found, interpret the next key
+        locally.
+        """
+        menu_active = False
+        try:
+            while self.alive:
+                try:
+                    b = console.getkey()
+                except KeyboardInterrupt:
+                    b = serial.to_bytes([3])
+                c = character(b)
+                if menu_active:
+                    if c == MENUCHARACTER or c == EXITCHARCTER: # Menu character again/exit char -> send itself
+                        self.serial.write(b)                    # send character
+                        if self.echo:
+                            sys.stdout.write(c)
+                    elif c == '\x15':                       # CTRL+U -> upload file
+                        sys.stderr.write('\n--- File to upload: ')
+                        sys.stderr.flush()
+                        console.cleanup()
+                        filename = sys.stdin.readline().rstrip('\r\n')
+                        if filename:
+                            try:
+                                file = open(filename, 'r')
+                                sys.stderr.write('--- Sending file %s ---\n' % filename)
+                                while True:
+                                    line = file.readline().rstrip('\r\n')
+                                    if not line:
+                                        break
+                                    self.serial.write(line)
+                                    self.serial.write('\r\n')
+                                    # Wait for output buffer to drain.
+                                    self.serial.flush()
+                                    sys.stderr.write('.')   # Progress indicator.
+                                sys.stderr.write('\n--- File %s sent ---\n' % filename)
+                            except IOError, e:
+                                sys.stderr.write('--- ERROR opening file %s: %s ---\n' % (filename, e))
+                        console.setup()
+                    elif c in '\x08hH?':                    # CTRL+H, h, H, ? -> Show help
+                        sys.stderr.write(get_help_text())
+                    elif c == '\x12':                       # CTRL+R -> Toggle RTS
+                        self.rts_state = not self.rts_state
+                        self.serial.setRTS(self.rts_state)
+                        sys.stderr.write('--- RTS %s ---\n' % (self.rts_state and 'active' or 'inactive'))
+                    elif c == '\x04':                       # CTRL+D -> Toggle DTR
+                        self.dtr_state = not self.dtr_state
+                        self.serial.setDTR(self.dtr_state)
+                        sys.stderr.write('--- DTR %s ---\n' % (self.dtr_state and 'active' or 'inactive'))
+                    elif c == '\x02':                       # CTRL+B -> toggle BREAK condition
+                        self.break_state = not self.break_state
+                        self.serial.setBreak(self.break_state)
+                        sys.stderr.write('--- BREAK %s ---\n' % (self.break_state and 'active' or 'inactive'))
+                    elif c == '\x05':                       # CTRL+E -> toggle local echo
+                        self.echo = not self.echo
+                        sys.stderr.write('--- local echo %s ---\n' % (self.echo and 'active' or 'inactive'))
+                    elif c == '\x09':                       # CTRL+I -> info
+                        self.dump_port_settings()
+                    elif c == '\x01':                       # CTRL+A -> cycle escape mode
+                        self.repr_mode += 1
+                        if self.repr_mode > 3:
+                            self.repr_mode = 0
+                        sys.stderr.write('--- escape data: %s ---\n' % (
+                            REPR_MODES[self.repr_mode],
+                        ))
+                    elif c == '\x0c':                       # CTRL+L -> cycle linefeed mode
+                        self.convert_outgoing += 1
+                        if self.convert_outgoing > 2:
+                            self.convert_outgoing = 0
+                        self.newline = NEWLINE_CONVERISON_MAP[self.convert_outgoing]
+                        sys.stderr.write('--- line feed %s ---\n' % (
+                            LF_MODES[self.convert_outgoing],
+                        ))
+                    elif c in 'pP':                         # P -> change port
+                        sys.stderr.write('\n--- Enter port name: ')
+                        sys.stderr.flush()
+                        console.cleanup()
+                        try:
+                            port = sys.stdin.readline().strip()
+                        except KeyboardInterrupt:
+                            port = None
+                        console.setup()
+                        if port and port != self.serial.port:
+                            # reader thread needs to be shut down
+                            self._stop_reader()
+                            # save settings
+                            settings = self.serial.getSettingsDict()
+                            try:
+                                try:
+                                    new_serial = serial.serial_for_url(port, do_not_open=True)
+                                except AttributeError:
+                                    # happens when the installed pyserial is older than 2.5. use the
+                                    # Serial class directly then.
+                                    new_serial = serial.Serial()
+                                    new_serial.port = port
+                                # restore settings and open
+                                new_serial.applySettingsDict(settings)
+                                new_serial.open()
+                                new_serial.setRTS(self.rts_state)
+                                new_serial.setDTR(self.dtr_state)
+                                new_serial.setBreak(self.break_state)
+                            except Exception, e:
+                                sys.stderr.write('--- ERROR opening new port: %s ---\n' % (e,))
+                                new_serial.close()
+                            else:
+                                self.serial.close()
+                                self.serial = new_serial
+                                sys.stderr.write('--- Port changed to: %s ---\n' % (self.serial.port,))
+                            # and restart the reader thread
+                            self._start_reader()
+                    elif c in 'bB':                         # B -> change baudrate
+                        sys.stderr.write('\n--- Baudrate: ')
+                        sys.stderr.flush()
+                        console.cleanup()
+                        backup = self.serial.baudrate
+                        try:
+                            self.serial.baudrate = int(sys.stdin.readline().strip())
+                        except ValueError, e:
+                            sys.stderr.write('--- ERROR setting baudrate: %s ---\n' % (e,))
+                            self.serial.baudrate = backup
+                        else:
+                            self.dump_port_settings()
+                        console.setup()
+                    elif c == '8':                          # 8 -> change to 8 bits
+                        self.serial.bytesize = serial.EIGHTBITS
+                        self.dump_port_settings()
+                    elif c == '7':                          # 7 -> change to 8 bits
+                        self.serial.bytesize = serial.SEVENBITS
+                        self.dump_port_settings()
+                    elif c in 'eE':                         # E -> change to even parity
+                        self.serial.parity = serial.PARITY_EVEN
+                        self.dump_port_settings()
+                    elif c in 'oO':                         # O -> change to odd parity
+                        self.serial.parity = serial.PARITY_ODD
+                        self.dump_port_settings()
+                    elif c in 'mM':                         # M -> change to mark parity
+                        self.serial.parity = serial.PARITY_MARK
+                        self.dump_port_settings()
+                    elif c in 'sS':                         # S -> change to space parity
+                        self.serial.parity = serial.PARITY_SPACE
+                        self.dump_port_settings()
+                    elif c in 'nN':                         # N -> change to no parity
+                        self.serial.parity = serial.PARITY_NONE
+                        self.dump_port_settings()
+                    elif c == '1':                          # 1 -> change to 1 stop bits
+                        self.serial.stopbits = serial.STOPBITS_ONE
+                        self.dump_port_settings()
+                    elif c == '2':                          # 2 -> change to 2 stop bits
+                        self.serial.stopbits = serial.STOPBITS_TWO
+                        self.dump_port_settings()
+                    elif c == '3':                          # 3 -> change to 1.5 stop bits
+                        self.serial.stopbits = serial.STOPBITS_ONE_POINT_FIVE
+                        self.dump_port_settings()
+                    elif c in 'xX':                         # X -> change software flow control
+                        self.serial.xonxoff = (c == 'X')
+                        self.dump_port_settings()
+                    elif c in 'rR':                         # R -> change hardware flow control
+                        self.serial.rtscts = (c == 'R')
+                        self.dump_port_settings()
+                    else:
+                        sys.stderr.write('--- unknown menu character %s --\n' % key_description(c))
+                    menu_active = False
+                elif c == MENUCHARACTER: # next char will be for menu
+                    menu_active = True
+                elif c == EXITCHARCTER: 
+                    self.stop()
+                    break                                   # exit app
+                elif c == '\n':
+                    self.serial.write(self.newline)         # send newline character(s)
+                    if self.echo:
+                        sys.stdout.write(c)                 # local echo is a real newline in any case
+                        sys.stdout.flush()
+                else:
+                    self.serial.write(b)                    # send byte
+                    if self.echo:
+                        sys.stdout.write(c)
+                        sys.stdout.flush()
+        except:
+            self.alive = False
+            raise
+
+def main():
+    import optparse
+
+    parser = optparse.OptionParser(
+        usage = "%prog [options] [port [baudrate]]",
+        description = "Miniterm - A simple terminal program for the serial port."
+    )
+
+    parser.add_option("-p", "--port",
+        dest = "port",
+        help = "port, a number or a device name. (deprecated option, use parameter instead)",
+        default = None
+    )
+
+    parser.add_option("-b", "--baud",
+        dest = "baudrate",
+        action = "store",
+        type = 'int',
+        help = "set baud rate, default %default",
+        default = 9600
+    )
+
+    parser.add_option("--parity",
+        dest = "parity",
+        action = "store",
+        help = "set parity, one of [N, E, O, S, M], default=N",
+        default = 'N'
+    )
+
+    parser.add_option("-e", "--echo",
+        dest = "echo",
+        action = "store_true",
+        help = "enable local echo (default off)",
+        default = False
+    )
+
+    parser.add_option("--rtscts",
+        dest = "rtscts",
+        action = "store_true",
+        help = "enable RTS/CTS flow control (default off)",
+        default = False
+    )
+
+    parser.add_option("--xonxoff",
+        dest = "xonxoff",
+        action = "store_true",
+        help = "enable software flow control (default off)",
+        default = False
+    )
+
+    parser.add_option("--cr",
+        dest = "cr",
+        action = "store_true",
+        help = "do not send CR+LF, send CR only",
+        default = False
+    )
+
+    parser.add_option("--lf",
+        dest = "lf",
+        action = "store_true",
+        help = "do not send CR+LF, send LF only",
+        default = False
+    )
+
+    parser.add_option("-D", "--debug",
+        dest = "repr_mode",
+        action = "count",
+        help = """debug received data (escape non-printable chars)
+--debug can be given multiple times:
+0: just print what is received
+1: escape non-printable characters, do newlines as unusual
+2: escape non-printable characters, newlines too
+3: hex dump everything""",
+        default = 0
+    )
+
+    parser.add_option("--rts",
+        dest = "rts_state",
+        action = "store",
+        type = 'int',
+        help = "set initial RTS line state (possible values: 0, 1)",
+        default = None
+    )
+
+    parser.add_option("--dtr",
+        dest = "dtr_state",
+        action = "store",
+        type = 'int',
+        help = "set initial DTR line state (possible values: 0, 1)",
+        default = None
+    )
+
+    parser.add_option("-q", "--quiet",
+        dest = "quiet",
+        action = "store_true",
+        help = "suppress non error messages",
+        default = False
+    )
+
+    parser.add_option("--exit-char",
+        dest = "exit_char",
+        action = "store",
+        type = 'int',
+        help = "ASCII code of special character that is used to exit the application",
+        default = 0x1d
+    )
+
+    parser.add_option("--menu-char",
+        dest = "menu_char",
+        action = "store",
+        type = 'int',
+        help = "ASCII code of special character that is used to control miniterm (menu)",
+        default = 0x14
+    )
+
+    (options, args) = parser.parse_args()
+
+    options.parity = options.parity.upper()
+    if options.parity not in 'NEOSM':
+        parser.error("invalid parity")
+
+    if options.cr and options.lf:
+        parser.error("only one of --cr or --lf can be specified")
+
+    if options.menu_char == options.exit_char:
+        parser.error('--exit-char can not be the same as --menu-char')
+
+    global EXITCHARCTER, MENUCHARACTER
+    EXITCHARCTER = chr(options.exit_char)
+    MENUCHARACTER = chr(options.menu_char)
+
+    port = options.port
+    baudrate = options.baudrate
+    if args:
+        if options.port is not None:
+            parser.error("no arguments are allowed, options only when --port is given")
+        port = args.pop(0)
+        if args:
+            try:
+                baudrate = int(args[0])
+            except ValueError:
+                parser.error("baud rate must be a number, not %r" % args[0])
+            args.pop(0)
+        if args:
+            parser.error("too many arguments")
+    else:
+        if port is None: port = 0
+
+    convert_outgoing = CONVERT_CRLF
+    if options.cr:
+        convert_outgoing = CONVERT_CR
+    elif options.lf:
+        convert_outgoing = CONVERT_LF
+
+    try:
+        miniterm = Miniterm(
+            port,
+            baudrate,
+            options.parity,
+            rtscts=options.rtscts,
+            xonxoff=options.xonxoff,
+            echo=options.echo,
+            convert_outgoing=convert_outgoing,
+            repr_mode=options.repr_mode,
+        )
+    except serial.SerialException, e:
+        sys.stderr.write("could not open port %r: %s\n" % (port, e))
+        sys.exit(1)
+
+    if not options.quiet:
+        sys.stderr.write('--- Miniterm on %s: %d,%s,%s,%s ---\n' % (
+            miniterm.serial.portstr,
+            miniterm.serial.baudrate,
+            miniterm.serial.bytesize,
+            miniterm.serial.parity,
+            miniterm.serial.stopbits,
+        ))
+        sys.stderr.write('--- Quit: %s  |  Menu: %s | Help: %s followed by %s ---\n' % (
+            key_description(EXITCHARCTER),
+            key_description(MENUCHARACTER),
+            key_description(MENUCHARACTER),
+            key_description('\x08'),
+        ))
+
+    if options.dtr_state is not None:
+        if not options.quiet:
+            sys.stderr.write('--- forcing DTR %s\n' % (options.dtr_state and 'active' or 'inactive'))
+        miniterm.serial.setDTR(options.dtr_state)
+        miniterm.dtr_state = options.dtr_state
+    if options.rts_state is not None:
+        if not options.quiet:
+            sys.stderr.write('--- forcing RTS %s\n' % (options.rts_state and 'active' or 'inactive'))
+        miniterm.serial.setRTS(options.rts_state)
+        miniterm.rts_state = options.rts_state
+
+    miniterm.start()
+    try:
+        miniterm.join(True)
+    except KeyboardInterrupt:
+        pass
+    if not options.quiet:
+        sys.stderr.write("\n--- exit ---\n")
+    miniterm.join()
+
+
+if __name__ == '__main__':
+    main()

bin/pasteurize

@@ -0,0 +1,11 @@
+#!/usr/local/CyberCP/bin/python2
+
+# -*- coding: utf-8 -*-
+import re
+import sys
+
+from libpasteurize.main import main
+
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

bin/pbr

@@ -0,0 +1,11 @@
+#!/usr/local/CyberCP/bin/python2
+
+# -*- coding: utf-8 -*-
+import re
+import sys
+
+from pbr.cmd.main import main
+
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

bin/pip

@@ -0,0 +1,11 @@
+#!/usr/local/CyberCP/bin/python2
+
+# -*- coding: utf-8 -*-
+import re
+import sys
+
+from pip._internal import main
+
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

bin/pip2

@@ -0,0 +1,11 @@
+#!/usr/local/CyberCP/bin/python2
+
+# -*- coding: utf-8 -*-
+import re
+import sys
+
+from pip._internal import main
+
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

bin/pip2.7

@@ -0,0 +1,11 @@
+#!/usr/local/CyberCP/bin/python2
+
+# -*- coding: utf-8 -*-
+import re
+import sys
+
+from pip._internal import main
+
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

bin/pybabel

@@ -0,0 +1,11 @@
+#!/usr/local/CyberCP/bin/python2
+
+# -*- coding: utf-8 -*-
+import re
+import sys
+
+from babel.messages.frontend import main
+
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

bin/python

@@ -0,0 +1 @@
+python2

bin/python-config

@@ -0,0 +1,78 @@
+#!/usr/local/CyberCP/bin/python
+
+import sys
+import getopt
+import sysconfig
+
+valid_opts = ['prefix', 'exec-prefix', 'includes', 'libs', 'cflags',
+              'ldflags', 'help']
+
+if sys.version_info >= (3, 2):
+    valid_opts.insert(-1, 'extension-suffix')
+    valid_opts.append('abiflags')
+if sys.version_info >= (3, 3):
+    valid_opts.append('configdir')
+
+
+def exit_with_usage(code=1):
+    sys.stderr.write("Usage: {0} [{1}]\n".format(
+        sys.argv[0], '|'.join('--'+opt for opt in valid_opts)))
+    sys.exit(code)
+
+try:
+    opts, args = getopt.getopt(sys.argv[1:], '', valid_opts)
+except getopt.error:
+    exit_with_usage()
+
+if not opts:
+    exit_with_usage()
+
+pyver = sysconfig.get_config_var('VERSION')
+getvar = sysconfig.get_config_var
+
+opt_flags = [flag for (flag, val) in opts]
+
+if '--help' in opt_flags:
+    exit_with_usage(code=0)
+
+for opt in opt_flags:
+    if opt == '--prefix':
+        print(sysconfig.get_config_var('prefix'))
+
+    elif opt == '--exec-prefix':
+        print(sysconfig.get_config_var('exec_prefix'))
+
+    elif opt in ('--includes', '--cflags'):
+        flags = ['-I' + sysconfig.get_path('include'),
+                 '-I' + sysconfig.get_path('platinclude')]
+        if opt == '--cflags':
+            flags.extend(getvar('CFLAGS').split())
+        print(' '.join(flags))
+
+    elif opt in ('--libs', '--ldflags'):
+        abiflags = getattr(sys, 'abiflags', '')
+        libs = ['-lpython' + pyver + abiflags]
+        libs += getvar('LIBS').split()
+        libs += getvar('SYSLIBS').split()
+        # add the prefix/lib/pythonX.Y/config dir, but only if there is no
+        # shared library in prefix/lib/.
+        if opt == '--ldflags':
+            if not getvar('Py_ENABLE_SHARED'):
+                libs.insert(0, '-L' + getvar('LIBPL'))
+            if not getvar('PYTHONFRAMEWORK'):
+                libs.extend(getvar('LINKFORSHARED').split())
+        print(' '.join(libs))
+
+    elif opt == '--extension-suffix':
+        ext_suffix = sysconfig.get_config_var('EXT_SUFFIX')
+        if ext_suffix is None:
+            ext_suffix = sysconfig.get_config_var('SO')
+        print(ext_suffix)
+
+    elif opt == '--abiflags':
+        if not getattr(sys, 'abiflags', None):
+            exit_with_usage()
+        print(sys.abiflags)
+
+    elif opt == '--configdir':
+        print(sysconfig.get_config_var('LIBPL'))

bin/python2.7

@@ -0,0 +1 @@
+python2

bin/tldextract

@@ -0,0 +1,11 @@
+#!/usr/local/CyberCP/bin/python2
+
+# -*- coding: utf-8 -*-
+import re
+import sys
+
+from tldextract.cli import main
+
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

bin/wheel

@@ -0,0 +1,11 @@
+#!/usr/local/CyberCP/bin/python2
+
+# -*- coding: utf-8 -*-
+import re
+import sys
+
+from wheel.cli import main
+
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

dockerManager/decorators.py

@@ -32,6 +32,7 @@ def preDockerRun(function):
                 return render(request, 'dockerManager/install.html', {'status':admin.type, 'conErr':0})
             
         # Check if docker is running and we are able to connect
+                
         try:
             client = docker.from_env()
             client.ping()

dockerManager/templates/dockerManager/runContainer.html

@@ -109,7 +109,7 @@
             </div>
 
             
-            <div class="col-md-offset-3">
+            <div ng-hide="installationDetailsForm" class="col-md-offset-3">
                 <button type="button" class="btn btn-info" ng-click="addEnvField()">Add more</button>
             </div><br>
                 <div ng-hide="installationDetailsForm" class="form-group">

dockerManager/views.py

@@ -13,8 +13,6 @@ import json
 import requests
 import docker
 
-# Use default socket to connect
-client = docker.from_env()
 # Create your views here.
 
 # This function checks if user has admin permissions

plogical/acl.py

@@ -106,9 +106,6 @@ class ACLManager:
             finalResponse['hostnameSSL'] = acl.hostnameSSL
             finalResponse['mailServerSSL'] = acl.mailServerSSL
 
-            # Container Management
-            finalResponse['assignContainer'] = acl.assignContainer
-
         return finalResponse
 
     @staticmethod
@@ -234,6 +231,24 @@ class ACLManager:
         adminNames.append(admin.userName)
         return adminNames
 
+    @staticmethod
+    def loadUserObjects(userID):
+        admin = Administrator.objects.get(pk=userID)
+        adminObjects = []
+
+        finalResponse = ACLManager.loadedACL(userID)
+
+        if finalResponse['admin'] == 1:
+            return Administrator.objects.all()
+        else:
+            admins = Administrator.objects.filter(owner=admin.pk)
+            for items in admins:
+                adminObjects.append(items)
+
+                adminObjects.append(admin)
+
+        return adminObjects
+
     @staticmethod
     def loadDeletionUsers(userID, finalResponse):
         admin = Administrator.objects.get(pk=userID)
@@ -315,6 +330,15 @@ class ACLManager:
 
         return packNames
 
+    @staticmethod
+    def loadPackageObjects(userID, finalResponse):
+        admin = Administrator.objects.get(pk=userID)
+
+        if finalResponse['admin'] == 1:
+            return Package.objects.all()
+        else:
+            return admin.package_set.all()
+
     @staticmethod
     def findAllSites(currentACL, userID):
         websiteNames = []
@@ -340,6 +364,7 @@ class ACLManager:
 
         return websiteNames
 
+    
     @staticmethod
     def findAllContainers(currentACL, userID):
         containerName = []
@@ -364,29 +389,6 @@ class ACLManager:
 
         return containerName
     
-    @staticmethod
-    def findWebsiteObjects(currentACL, userID):
-
-        if currentACL['admin'] == 1:
-            return Websites.objects.all()
-        else:
-
-            websiteList = []
-            admin = Administrator.objects.get(pk=userID)
-
-            websites = admin.websites_set.all()
-
-            for items in websites:
-                websiteList.append(items)
-
-            admins = Administrator.objects.filter(owner=admin.pk)
-
-            for items in admins:
-                webs = items.websites_set.all()
-                for web in webs:
-                    websiteList.append(web)
-
-            return websiteList
     
     @staticmethod
     def findContainersObjects(currentACL, userID):
@@ -412,6 +414,47 @@ class ACLManager:
 
             return containerList        
         
+    
+    @staticmethod
+    def checkContainerOwnership(name, userID):
+        try:
+            container = Containers.objects.get(name=name)
+            currentACL = ACLManager.loadedACL(userID)
+            admin = Administrator.objects.get(pk=userID)
+
+            if currentACL['admin'] == 1:
+                return 1
+            elif container.admin == admin:
+                return 1
+            else:
+                return 0
+        except:
+            return 0        
+    
+    @staticmethod
+    def findWebsiteObjects(currentACL, userID):
+
+        if currentACL['admin'] == 1:
+            return Websites.objects.all()
+        else:
+
+            websiteList = []
+            admin = Administrator.objects.get(pk=userID)
+
+            websites = admin.websites_set.all()
+
+            for items in websites:
+                websiteList.append(items)
+
+            admins = Administrator.objects.filter(owner=admin.pk)
+
+            for items in admins:
+                webs = items.websites_set.all()
+                for web in webs:
+                    websiteList.append(web)
+
+            return websiteList
+
     @staticmethod
     def findAllDomains(currentACL, userID):
         domainsList = []
@@ -463,22 +506,6 @@ class ACLManager:
                 else:
                     return 0
 
-    @staticmethod
-    def checkContainerOwnership(name, userID):
-        try:
-            container = Containers.objects.get(name=name)
-            currentACL = ACLManager.loadedACL(userID)
-            admin = Administrator.objects.get(pk=userID)
-            
-            if currentACL['admin'] == 1:
-                return 1
-            elif container.admin == admin:
-                return 1
-            else:
-                return 0
-        except:
-            return 0
-
     @staticmethod
     def executeCall(command):
         try:
@@ -497,4 +524,3 @@ class ACLManager:
 
 
 
-

plogical/container.py

@@ -25,9 +25,6 @@ import docker.utils
 import requests
 
 # Use default socket to connect
-client = docker.from_env()
-dockerAPI = docker.APIClient()
-
 class ContainerManager:
     def __init__(self, name = None):
         self.name = name
@@ -38,11 +35,23 @@ class ContainerManager:
             if ACLManager.currentContextPermission(currentACL, 'createContainer') == 0:
                 return ACLManager.loadError()
             
-            command = 'yum install -y docker'
+            command = 'sudo yum install -y docker'
             cmd = shlex.split(command)
             res = subprocess.call(cmd)
             
-            if res == 0:
+            command = 'sudo groupadd docker'
+            cmd = shlex.split(command)
+            res2 = subprocess.call(cmd)
+            
+            command = 'sudo usermod -aG docker cyberpanel'
+            cmd = shlex.split(command)
+            res3 = subprocess.call(cmd)
+            
+            command = 'sudo service docker start'
+            cmd = shlex.split(command)
+            res4 = subprocess.call(cmd)
+            
+            if res == 0 and res2 == 0 and res3 == 0 and res4 ==0:
                 data_ret = {'installDockerStatus': 1, 'error_message': 'None'}
                 json_data = json.dumps(data_ret)
                 return HttpResponse(json_data)
@@ -58,10 +67,13 @@ class ContainerManager:
             
     def createContainer(self, request = None, userID = None, data = None):
         try:            
-            currentACL = ACLManager.loadedACL(userID)
+            admin = Administrator.objects.get(pk=userID)
-            if ACLManager.currentContextPermission(currentACL, 'createContainer') == 0:
+            if admin.acl.adminStatus != 1:
                 return ACLManager.loadError()
                 
+            client = docker.from_env()
+            dockerAPI = docker.APIClient()
+        
             adminNames = ACLManager.loadAllUsers(userID)
             tag = request.GET.get('tag')
             image = request.GET.get('image')
@@ -97,7 +109,6 @@ class ContainerManager:
                     portDef = item.split('/')
                     portConfig[portDef[0]] = portDef[1]                
             
-            print portConfig
             if image is None or image is '' or tag is None or tag is '':
                 return redirect(loadImages)
             
@@ -114,6 +125,8 @@ class ContainerManager:
         if ACLManager.checkContainerOwnership(name, userID) != 1:
             return ACLManager.loadError()
         
+        client = docker.from_env()
+        dockerAPI = docker.APIClient()
         try:
             container = client.containers.get(name)
         except docker.errors.NotFound as err:
@@ -161,6 +174,11 @@ class ContainerManager:
         
     def listContainers(self, request = None, userID = None, data = None):
         try:
+            if ACLManager.checkContainerOwnership(name, userID) != 1:
+                return ACLManager.loadError()
+            client = docker.from_env()
+            dockerAPI = docker.APIClient()
+            
             currentACL = ACLManager.loadedACL(userID)
             containers = ACLManager.findAllContainers(currentACL, userID)
             
@@ -209,6 +227,9 @@ class ContainerManager:
                 if ACLManager.checkContainerOwnership(name, userID) != 1:
                     return ACLManager.loadErrorJson('containerLogStatus',0)
                 
+            client = docker.from_env()
+            dockerAPI = docker.APIClient()                
+            
             container = client.containers.get(name)
             logs = container.logs()
 
@@ -225,9 +246,12 @@ class ContainerManager:
     def submitContainerCreation(self, userID = None, data = None):
         try:
 
-            currentACL = ACLManager.loadedACL(userID)
+            admin = Administrator.objects.get(pk=userID)
-            if ACLManager.currentContextPermission(currentACL, 'createWebsite') == 0:
+            if admin.acl.adminStatus != 1:
-                return ACLManager.loadErrorJson('createWebSiteStatus', 0)
+                return ACLManager.loadErrorJson('createContainerStatus',0)
+                
+            client = docker.from_env()
+            dockerAPI = docker.APIClient()
 
             name = data['name']
             image = data['image']
@@ -300,9 +324,12 @@ class ContainerManager:
     def submitInstallImage(self, userID = None, data = None):
         try:
 
-            currentACL = ACLManager.loadedACL(userID)
+            admin = Administrator.objects.get(pk=userID)
-            if ACLManager.currentContextPermission(currentACL, 'createWebsite') == 0:
+            if admin.acl.adminStatus != 1:
-                return ACLManager.loadErrorJson('createWebSiteStatus', 0)
+                return ACLManager.loadErrorJson('installImageStatus',0)
+                
+            client = docker.from_env()
+            dockerAPI = docker.APIClient()
 
             image = data['image']
             tag = data['tag']
@@ -345,6 +372,9 @@ class ContainerManager:
                     else:
                         return ACLManager.loadErrorJson('websiteDeleteStatus', 0)
 
+            client = docker.from_env()
+            dockerAPI = docker.APIClient()
+            
             unlisted = data['unlisted']
             
             if 'force' in data:
@@ -406,6 +436,10 @@ class ContainerManager:
 
     def getContainerList(self, userID = None, data = None):
         try:
+            admin = Administrator.objects.get(pk=userID)
+            if admin.acl.adminStatus != 1:
+                return ACLManager.loadErrorJson('listContainerStatus',0)
+            
             currentACL = ACLManager.loadedACL(userID)
             pageNumber = int(data['page'])
             json_data = self.findContainersJson(currentACL, userID, pageNumber)
@@ -418,6 +452,10 @@ class ContainerManager:
             return HttpResponse(json_data)        
         
     def findContainersJson(self, currentACL, userID, pageNumber):
+        admin = Administrator.objects.get(pk=userID)
+        if admin.acl.adminStatus != 1:
+            return ACLManager.loadError()
+            
         finalPageNumber = ((pageNumber * 10)) - 10
         endPageNumber = finalPageNumber + 10
         containers = ACLManager.findContainersObjects(currentACL, userID)[finalPageNumber:endPageNumber]
@@ -445,6 +483,9 @@ class ContainerManager:
             if ACLManager.checkContainerOwnership(name, userID) != 1:
                 return ACLManager.loadErrorJson('containerActionStatus',0)
             
+            client = docker.from_env()
+            dockerAPI = docker.APIClient()
+            
             action = data['action']
             try:
                 container = client.containers.get(name)
@@ -490,6 +531,9 @@ class ContainerManager:
             if ACLManager.checkContainerOwnership(name, userID) != 1:
                 return ACLManager.loadErrorJson('containerStatus',0)
             
+            client = docker.from_env()
+            dockerAPI = docker.APIClient()
+            
             try:
                 container = client.containers.get(name)
             except docker.errors.NotFound as err:
@@ -517,6 +561,9 @@ class ContainerManager:
             if ACLManager.checkContainerOwnership(name, userID) != 1:
                 return ACLManager.loadErrorJson('containerStatus',0)
             
+            client = docker.from_env()
+            dockerAPI = docker.APIClient()
+            
             try:
                 container = client.containers.get(name)
             except docker.errors.NotFound as err:
@@ -543,6 +590,10 @@ class ContainerManager:
             name = data['name']
             if ACLManager.checkContainerOwnership(name, userID) != 1:
                 return ACLManager.loadErrorJson('containerTopStatus',0)
+            
+            client = docker.from_env()
+            dockerAPI = docker.APIClient()
+            
             try:
                 container = client.containers.get(name)
             except docker.errors.NotFound as err:
@@ -573,6 +624,13 @@ class ContainerManager:
     def assignContainer(self, userID = None, data = None):
         try:
             # Todo: add check only for super user i.e. main admin
+            admin = Administrator.objects.get(pk=userID)
+            if admin.acl.adminStatus != 1:
+                return ACLManager.loadErrorJson('assignContainerStatus',0)
+                
+            client = docker.from_env()
+            dockerAPI = docker.APIClient()
+            
             name = data['name']
             dockerOwner = data['admin']
                 
@@ -606,6 +664,13 @@ class ContainerManager:
                 
     def searchImage(self, userID = None, data = None):
         try:
+            admin = Administrator.objects.get(pk=userID)
+            if admin.acl.adminStatus != 1:
+                return ACLManager.loadErrorJson('searchImageStatus',0)
+                
+            client = docker.from_env()
+            dockerAPI = docker.APIClient()
+            
             string = data['string']
             try:
                 matches = client.images.search(term=string)
@@ -638,6 +703,13 @@ class ContainerManager:
         
     def images(self, request = None, userID = None, data = None):
         try:
+            admin = Administrator.objects.get(pk=userID)
+            if admin.acl.adminStatus != 1:
+                return ACLManager.loadError()
+                
+            client = docker.from_env()
+            dockerAPI = docker.APIClient()
+            
             try:
                 imageList = client.images.list()
             except docker.errors.APIError as err:
@@ -677,6 +749,13 @@ class ContainerManager:
     
     def manageImages(self, request = None, userID = None, data = None):
         try:
+            admin = Administrator.objects.get(pk=userID)
+            if admin.acl.adminStatus != 1:
+                return ACLManager.loadError()
+                
+            client = docker.from_env()
+            dockerAPI = docker.APIClient()
+            
             imageList = client.images.list()
             
             images = {}
@@ -700,6 +779,13 @@ class ContainerManager:
         try:
 
             name = data['name']
+            
+            if ACLManager.checkContainerOwnership(name, userID) != 1:
+                return ACLManager.loadError()
+            
+            client = docker.from_env()
+            dockerAPI = docker.APIClient()
+            
             try:
                 image = client.images.get(name)
             except docker.errors.APIError as err:
@@ -724,6 +810,13 @@ class ContainerManager:
         
     def removeImage(self, userID = None, data = None):
         try:
+            admin = Administrator.objects.get(pk=userID)
+            if admin.acl.adminStatus != 1:
+                return ACLManager.loadError()
+                
+            client = docker.from_env()
+            dockerAPI = docker.APIClient()
+            
             name = data['name']
             try:
                 if name == 0:
@@ -796,6 +889,9 @@ class ContainerManager:
             if ACLManager.checkContainerOwnership(name, userID) != 1:
                 return ACLManager.loadErrorJson('saveSettingsStatus',0)
                 
+            client = docker.from_env()
+            dockerAPI = docker.APIClient()
+            
             memory = data['memory']
             startOnReboot = data['startOnReboot']
             envList = data['envList']
@@ -873,6 +969,9 @@ class ContainerManager:
             if ACLManager.checkContainerOwnership(name, userID) != 1:
                 return ACLManager.loadErrorJson('saveSettingsStatus',0)
             
+            client = docker.from_env()
+            dockerAPI = docker.APIClient()
+            
             try:
                 container = client.containers.get(name)
             except docker.errors.NotFound as err:
@@ -914,6 +1013,11 @@ class ContainerManager:
         
     def getTags(self, userID = None, data = None):
         try:
+            
+            admin = Administrator.objects.get(pk=userID)
+            if admin.acl.adminStatus != 1:
+                return ACLManager.loadError()
+            
             image = data['image']
             page = data['page']