text: """
      SoftLayer.cdn
      ~~~~~~~~~~~~~
      CDN Manager/helpers
  
      :license: MIT, see LICENSE for more details.
  """
  import six
  
  from SoftLayer import utils
  
  
  MAX_URLS_PER_LOAD = 5
  MAX_URLS_PER_PURGE = 5
  
  
  class CDNManager(utils.IdentifierMixin, object):
      """Manage CDN accounts and content.
  
      See product information here:
      http://www.softlayer.com/content-delivery-network
  
      :param SoftLayer.API.BaseClient client: the client instance
      """
  
      def __init__(self, client):
          self.client = client
          self.account = self.client['Network_ContentDelivery_Account']
  
      def list_accounts(self):
          """Lists CDN accounts for the active user."""
  
          account = self.client['Account']
          mask = 'cdnAccounts[%s]' % ', '.join(['id',
                                                'createDate',
                                                'cdnAccountName',
                                                'cdnSolutionName',
                                                'cdnAccountNote',
                                                'status'])
          return account.getObject(mask=mask).get('cdnAccounts', [])
  
      def get_account(self, account_id, **kwargs):
          """Retrieves a CDN account with the specified account ID.
  
          :param account_id int: the numeric ID associated with the CDN account.
          :param dict \\*\\*kwargs: additional arguments to include in the object
                                  mask.
          """
  
          if 'mask' not in kwargs:
              kwargs['mask'] = 'status'
  
          return self.account.getObject(id=account_id, **kwargs)
  
      def get_origins(self, account_id, **kwargs):
          """Retrieves list of origin pull mappings for a specified CDN account.
  
          :param account_id int: the numeric ID associated with the CDN account.
          :param dict \\*\\*kwargs: additional arguments to include in the object
                                  mask.
          """
  
          return self.account.getOriginPullMappingInformation(id=account_id,
                                                              **kwargs)
  
      def add_origin(self, account_id, media_type, origin_url, cname=None,
                     secure=False):
          """Adds an original pull mapping to an origin-pull.
  
          :param int account_id: the numeric ID associated with the CDN account.
          :param string media_type: the media type/protocol associated with this
                                    origin pull mapping; valid values are HTTP,
                                    FLASH, and WM.
          :param string origin_url: the base URL from which content should be
                                    pulled.
          :param string cname: an optional CNAME that should be associated with
                               this origin pull rule; only the hostname should be
                               included (i.e., no 'http://', directories, etc.).
          :param boolean secure: specifies whether this is an SSL origin pull
                                 rule, if SSL is enabled on your account
                                 (defaults to false).
          """
  
          config = {'mediaType': media_type,
                    'originUrl': origin_url,
                    'isSecureContent': secure}
  
          if cname:
              config['cname'] = cname
  
          return self.account.createOriginPullMapping(config, id=account_id)
  
      def remove_origin(self, account_id, origin_id):
          """Removes an origin pull mapping with the given origin pull ID.
  
          :param int account_id: the CDN account ID from which the mapping should
                                 be deleted.
          :param int origin_id: the origin pull mapping ID to delete.
          """
  
          return self.account.deleteOriginPullRule(origin_id, id=account_id)
  
      def load_content(self, account_id, urls):
          """Prefetches one or more URLs to the CDN edge nodes.
  
          :param int account_id: the CDN account ID into which content should be
                                 preloaded.
          :param urls: a string or a list of strings representing the CDN URLs
                       that should be pre-loaded.
          :returns: true if all load requests were successfully submitted;
                    otherwise, returns the first error encountered.
          """
  
          if isinstance(urls, six.string_types):
              urls = [urls]
  
          for i in range(0, len(urls), MAX_URLS_PER_LOAD):
              result = self.account.loadContent(urls[i:i + MAX_URLS_PER_LOAD],
                                                id=account_id)
              if not result:
                  return result
  
          return True
  
      def purge_content(self, account_id, urls):
          """Purges one or more URLs from the CDN edge nodes.
  
          :param int account_id: the CDN account ID from which content should
                                 be purged.
          :param urls: a string or a list of strings representing the CDN URLs
                       that should be purged.
          :returns: true if all purge requests were successfully submitted;
                    otherwise, returns the first error encountered.
          """
  
          if isinstance(urls, six.string_types):
              urls = [urls]
  
          for i in range(0, len(urls), MAX_URLS_PER_PURGE):
              result = self.account.purgeCache(urls[i:i + MAX_URLS_PER_PURGE],
                                               id=account_id)
              if not result:
                  return result
  
          return True
  