# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements.  See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# libcloud.org licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License.  You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# Maintainer: Jed Smith <jsmith@linode.com>
#
# BETA TESTING THE LINODE API AND DRIVERS
#
# A beta account that incurs no financial charge may be arranged for.  Please
# contact Jed Smith <jsmith@linode.com> for your request.
#
"""
Linode driver
"""
from libcloud.types import Provider, NodeState, InvalidCredsException
from libcloud.base import ConnectionKey, Response
from libcloud.base import NodeDriver, NodeSize, Node, NodeLocation
from libcloud.base import NodeAuthPassword, NodeAuthSSHKey
from libcloud.base import NodeImage
from copy import copy
import os

# JSON is included in the standard library starting with Python 2.6.  For 2.5
# and 2.4, there's a simplejson egg at: http://pypi.python.org/pypi/simplejson
try: import json
except: import simplejson as json


# Base exception for problems arising from this driver
class LinodeException(Exception):
    def __str__(self):
        return "(%u) %s" % (self.args[0], self.args[1])
    def __repr__(self):
        return "<LinodeException code %u '%s'>" % (self.args[0], self.args[1])

# For beta accounts, change this to "beta.linode.com".
LINODE_API = "api.linode.com"

# For beta accounts, change this to "/api/".
LINODE_ROOT = "/"


class LinodeResponse(Response):
    # Wraps a Linode API HTTP response.
    
    def __init__(self, response):
        # Given a response object, slurp the information from it.
        self.body = response.read()
        self.status = response.status
        self.headers = dict(response.getheaders())
        self.error = response.reason
        self.invalid = LinodeException(0xFF,
                                       "Invalid JSON received from server")
        
        # Move parse_body() to here;  we can't be sure of failure until we've
        # parsed the body into JSON.
        self.action, self.object, self.errors = self.parse_body()
        
        if self.error == "Moved Temporarily":
            raise LinodeException(0xFA,
                                  "Redirected to error page by API.  Bug?")

        if not self.success():
            # Raise the first error, as there will usually only be one
            raise self.errors[0]
    
    def parse_body(self):
        # Parse the body of the response into JSON.  Will return None if the
        # JSON response chokes the parser.  Returns a triple:
        #    (action, data, errorarray)
        try:
            js = json.loads(self.body)
            if ("DATA" not in js
                or "ERRORARRAY" not in js
                or "ACTION" not in js):

                return (None, None, [self.invalid])
            errs = [self._make_excp(e) for e in js["ERRORARRAY"]]
            return (js["ACTION"], js["DATA"], errs)
        except:
            # Assume invalid JSON, and use an error code unused by Linode API.
            return (None, None, [self.invalid])
    
    def parse_error(self):
        # Obtain the errors from the response.  Will always return a list.
        try:
            js = json.loads(self.body)
            if "ERRORARRAY" not in js:
                return [self.invalid]
            return [self._make_excp(e) for e in js["ERRORARRAY"]]
        except:
            return [self.invalid]
    
    def success(self):
        # Does the response indicate success?  If ERRORARRAY has more than one
        # entry, we'll say no.
        return len(self.errors) == 0
    
    def _make_excp(self, error):
        # Make an exception from an entry in ERRORARRAY.
        if "ERRORCODE" not in error or "ERRORMESSAGE" not in error:
            return None
        if error["ERRORCODE"] ==  4:
          return InvalidCredsException(error["ERRORMESSAGE"])
        return LinodeException(error["ERRORCODE"], error["ERRORMESSAGE"])
        

class LinodeConnection(ConnectionKey):
    # Wraps a Linode HTTPS connection, and passes along the connection key.
    host = LINODE_API
    responseCls = LinodeResponse
    def add_default_params(self, params):
        params["api_key"] = self.key
        # Be explicit about this in case the default changes.
        params["api_responseFormat"] = "json"
        return params


class LinodeNodeDriver(NodeDriver):
    # The meat of Linode operations; the Node Driver.
    type = Provider.LINODE
    name = "Linode"
    connectionCls = LinodeConnection
    
    def __init__(self, key):
        self.datacenter = None
        NodeDriver.__init__(self, key)

    # Converts Linode's state from DB to a NodeState constant.
    # Some of these are lightly questionable.
    LINODE_STATES = {
        -2: NodeState.UNKNOWN,              # Boot Failed
        -1: NodeState.PENDING,              # Being Created
         0: NodeState.PENDING,              # Brand New
         1: NodeState.RUNNING,              # Running
         2: NodeState.REBOOTING,            # Powered Off (TODO: Extra state?)
         3: NodeState.REBOOTING,            # Shutting Down (?)
         4: NodeState.UNKNOWN               # Reserved
    }

    def list_nodes(self):
        # List
        # Provide a list of all nodes that this API key has access to.
        params = { "api_action": "linode.list" }
        data = self.connection.request(LINODE_ROOT, params=params).object
        return [self._to_node(n) for n in data]
    
    def reboot_node(self, node):
        # Reboot
        # Execute a shutdown and boot job for the given Node.
        params = { "api_action": "linode.reboot", "LinodeID": node.id }
        self.connection.request(LINODE_ROOT, params=params)
        return True
    
    def destroy_node(self, node):
        # Destroy
        # Terminates a Node.  With prejudice.
        params = { "api_action": "linode.delete", "LinodeID": node.id,
            "skipChecks": True }
        self.connection.request(LINODE_ROOT, params=params)
        return True

    def create_node(self, **kwargs):
        """Create a new linode instance

        See L{NodeDriver.create_node} for more keyword args.

        @keyword    swap: Size of the swap partition in MB (128).
        @type       swap: C{number}

        @keyword    rsize: Size of the root partition (plan size - swap).
        @type       rsize: C{number}

        @keyword    kernel: A kernel ID from avail.kernels (Latest 2.6).
        @type       kernel: C{number}

        @keyword    payment: One of 1, 12, or 24; subscription length (1)
        @type       payment: C{number}

        @keyword    comment: Comments to store with the config
        @type       comment: C{str}
        """
        #    Labels to override what's generated (default on right):
        #       lconfig      [%name] Instance
        #       lrecovery    [%name] Finnix Recovery Configuration
        #       lroot        [%name] %distro
        #       lswap        [%name] Swap Space
        #
        # Datacenter logic:
        #
        #   As Linode requires choosing a datacenter, a little logic is done.
        #
        #   1. If the API key in use has all its Linodes in one DC, that DC will
        #      be chosen (and can be overridden with linode_set_datacenter).
        #
        #   2. Otherwise (for both the "No Linodes" and "different DC" cases), a
        #      datacenter must explicitly be chosen using linode_set_datacenter.
        #
        # Please note that for safety, only 5 Linodes can be created per hour.

        name = kwargs["name"]
        chosen = kwargs["location"].id
        image = kwargs["image"]
        size = kwargs["size"]
        auth = kwargs["auth"]

        # Step 0: Parameter validation before we purchase
        # We're especially careful here so we don't fail after purchase, rather
        # than getting halfway through the process and having the API fail.

        # Plan ID
        plans = self.list_sizes()
        if size.id not in [p.id for p in plans]:
            raise LinodeException(0xFB, "Invalid plan ID -- avail.plans")

        # Payment schedule
        payment = "1" if "payment" not in kwargs else str(kwargs["payment"])
        if payment not in ["1", "12", "24"]:
            raise LinodeException(0xFB, "Invalid subscription (1, 12, 24)")

        ssh = None
        root = None
        # SSH key and/or root password
        if isinstance(auth, NodeAuthSSHKey):
            ssh = auth.pubkey
        elif isinstance(auth, NodeAuthPassword):
            root = auth.password

        if not ssh and not root:
            raise LinodeException(0xFB, "Need SSH key or root password")
        if len(root) < 6:
            raise LinodeException(0xFB, "Root password is too short")

        # Swap size
        try: swap = 128 if "swap" not in kwargs else int(kwargs["swap"])
        except: raise LinodeException(0xFB, "Need an integer swap size")

        # Root partition size
        imagesize = (size.disk - swap) if "rsize" not in kwargs else \
            int(kwargs["rsize"])
        if (imagesize + swap) > size.disk:
            raise LinodeException(0xFB, "Total disk images are too big")

        # Distribution ID
        distros = self.list_images()
        if image.id not in [d.id for d in distros]:
            raise LinodeException(0xFB,
                                  "Invalid distro -- avail.distributions")

        # Kernel
        kernel = 60 if "kernel" not in kwargs else kwargs["kernel"]
        params = { "api_action": "avail.kernels" }
        kernels = self.connection.request(LINODE_ROOT, params=params).object
        if kernel not in [z["KERNELID"] for z in kernels]:
            raise LinodeException(0xFB, "Invalid kernel -- avail.kernels")

        # Comments
        comments = "Created by libcloud <http://www.libcloud.org>" if \
            "comment" not in kwargs else kwargs["comment"]

        # Labels
        label = {
            "lconfig": "[%s] Configuration Profile" % name,
            "lrecovery": "[%s] Finnix Recovery Configuration" % name,
            "lroot": "[%s] %s Disk Image" % (name, image.name),
            "lswap": "[%s] Swap Space" % name
        }
        for what in ["lconfig", "lrecovery", "lroot", "lswap"]:
            if what in kwargs:
                label[what] = kwargs[what]

        # Step 1: linode.create
        params = {
            "api_action":   "linode.create",
            "DatacenterID": chosen,
            "PlanID":       size.id,
            "PaymentTerm":  payment
        }
        data = self.connection.request(LINODE_ROOT, params=params).object
        linode = { "id": data["LinodeID"] }

        # Step 2: linode.disk.createfromdistribution
        if not root:
            root = os.urandom(16).encode('hex')
        params = {
            "api_action":       "linode.disk.createfromdistribution",
            "LinodeID":         linode["id"],
            "DistributionID":   image.id,
            "Label":            label["lroot"],
            "Size":             imagesize,
            "rootPass":         root,
        }
        if ssh: params["rootSSHKey"] = ssh
        data = self.connection.request(LINODE_ROOT, params=params).object
        linode["rootimage"] = data["DiskID"]

        # Step 3: linode.disk.create for swap
        params = {
            "api_action":       "linode.disk.create",
            "LinodeID":         linode["id"],
            "Label":            label["lswap"],
            "Type":             "swap",
            "Size":             swap
        }
        data = self.connection.request(LINODE_ROOT, params=params).object
        linode["swapimage"] = data["DiskID"]

        # Step 4: linode.config.create for main profile
        disks = "%s,%s,,,,,,," % (linode["rootimage"], linode["swapimage"])
        params = {
            "api_action":       "linode.config.create",
            "LinodeID":         linode["id"],
            "KernelID":         kernel,
            "Label":            label["lconfig"],
            "Comments":         comments,
            "DiskList":         disks
        }
        data = self.connection.request(LINODE_ROOT, params=params).object
        linode["config"] = data["ConfigID"]

        # TODO: Recovery image (Finnix)

        # Step 5: linode.boot
        params = {
            "api_action":       "linode.boot",
            "LinodeID":         linode["id"],
            "ConfigID":         linode["config"]
        }
        data = self.connection.request(LINODE_ROOT, params=params).object

        # Make a node out of it and hand it back
        params = { "api_action": "linode.list", "LinodeID": linode["id"] }
        data = self.connection.request(LINODE_ROOT, params=params).object
        return self._to_node(data[0])

    def list_sizes(self, location=None):
        # List Sizes
        # Retrieve all available Linode plans.
        # FIXME: Prices get mangled due to 'float'.
        params = { "api_action": "avail.linodeplans" }
        data = self.connection.request(LINODE_ROOT, params=params).object
        sizes = []
        for obj in data:
            n = NodeSize(id=obj["PLANID"], name=obj["LABEL"], ram=obj["RAM"],
                    disk=(obj["DISK"] * 1024), bandwidth=obj["XFER"],
                    price=obj["PRICE"], driver=self.connection.driver)
            sizes.append(n)
        return sizes
    
    def list_images(self, location=None):
        # List Images
        # Retrieve all available Linux distributions.
        params = { "api_action": "avail.distributions" }
        data = self.connection.request(LINODE_ROOT, params=params).object
        distros = []
        for obj in data:
            i = NodeImage(id=obj["DISTRIBUTIONID"], name=obj["LABEL"],
                driver=self.connection.driver)
            distros.append(i)
        return distros

    def list_locations(self):
        params = { "api_action": "avail.datacenters" }
        data = self.connection.request(LINODE_ROOT, params=params).object
        nl = []
        for dc in data:
            country = None
            #TODO: this is a hack!
            if dc["LOCATION"][-3:] == "USA":
                country = "US"
            elif dc["LOCATION"][-2:] == "UK":
                country = "GB"
            else:
                raise LinodeException(
                    0xFD,
                    "Unable to convert data center location to country: '%s'"
                    % dc["LOCATION"]
                )
            nl.append(NodeLocation(dc["DATACENTERID"],
                                   dc["LOCATION"],
                                   country,
                                   self))
        return nl

    def linode_set_datacenter(self, did):
        # Set the datacenter for create requests.
        #
        # Create will try to guess, based on where all of the API key's
        # Linodes are located; if they are all in one location, Create will
        # make a new node there.  If there are NO Linodes on the account or
        # Linodes are in multiple locations, it is imperative to set this or
        # creates will fail.
        params = { "api_action": "avail.datacenters" }
        data = self.connection.request(LINODE_ROOT, params=params).object
        for dc in data:
            if did == dc["DATACENTERID"]:
                self.datacenter = did
                return

        dcs = ", ".join([d["DATACENTERID"] for d in data])
        self.datacenter = None
        raise LinodeException(0xFD, "Invalid datacenter (use one of %s)" % dcs)

    def _to_node(self, obj):
        # Convert a returned Linode instance into a Node instance.
        lid = obj["LINODEID"]
        
        # Get the IP addresses for a Linode
        params = { "api_action": "linode.ip.list", "LinodeID": lid }        
        req = self.connection.request(LINODE_ROOT, params=params)
        if not req.success() or len(req.object) == 0:
            return None
        
        public_ip = []
        private_ip = []
        for ip in req.object:
            if ip["ISPUBLIC"]:
              public_ip.append(ip["IPADDRESS"])
            else:
              private_ip.append(ip["IPADDRESS"])

        n = Node(id=lid, name=obj["LABEL"],
            state=self.LINODE_STATES[obj["STATUS"]], public_ip=public_ip,
            private_ip=private_ip, driver=self.connection.driver)
        n.extra = copy(obj)
        return n

    features = {"create_node": ["ssh_key", "password"]}