/**
   * Populates the object from the XMLStreamReader
   *
   * @param xmlr the XMLStreamReader to read from
   * @throws XMLStreamException if there is an error parsing the stream
   * @throws ParseException if there is an error in parsing a date
   * @throws URISyntaxException if the uri is invalid
   */
  protected static BlobContainerAttributes readBlobContainerAttributes(final XMLStreamReader xmlr)
      throws XMLStreamException, ParseException, URISyntaxException {
    int eventType = xmlr.getEventType();

    final BlobContainerAttributes attributes = new BlobContainerAttributes();

    while (xmlr.hasNext()) {
      eventType = xmlr.next();
      final String name = xmlr.getName().toString();
      if (eventType == XMLStreamConstants.START_ELEMENT) {
        if (name.equals(BlobConstants.PROPERTIES)) {
          attributes.setProperties(BlobDeserializationHelper.readBlobContainerProperties(xmlr));
          xmlr.require(XMLStreamConstants.END_ELEMENT, null, BlobConstants.PROPERTIES);
        } else if (name.equals(Constants.URL_ELEMENT)) {
          attributes.setUri(new URI(Utility.readElementFromXMLReader(xmlr, Constants.URL_ELEMENT)));
        } else if (name.equals(Constants.NAME_ELEMENT)) {
          attributes.setName(Utility.readElementFromXMLReader(xmlr, Constants.NAME_ELEMENT));
        } else if (name.equals(Constants.METADATA_ELEMENT)) {
          // parse metadata
          attributes.setMetadata(DeserializationHelper.parseMetadateFromXML(xmlr));
          xmlr.require(XMLStreamConstants.END_ELEMENT, null, Constants.METADATA_ELEMENT);
        }
      } else if (eventType == XMLStreamConstants.END_ELEMENT
          && name.equals(BlobConstants.CONTAINER_ELEMENT)) {
        break;
      }
    }

    return attributes;
  }
  /**
   * Reserved for internal use. Perform a merge operation on the specified table, using the
   * specified {@link TableRequestOptions} and {@link OperationContext}.
   *
   * <p>This method will invoke the Merge Entity REST API to execute this table operation, using the
   * Table service endpoint and storage account credentials in the {@link CloudTableClient} object.
   *
   * @param client A {@link CloudTableClient} instance specifying the Table service endpoint,
   *     storage account credentials, and any additional query parameters.
   * @param tableName A <code>String</code> containing the name of the table.
   * @param options A {@link TableRequestOptions} object that specifies execution options such as
   *     retry policy and timeout settings for the operation.
   * @param opContext An {@link OperationContext} object for tracking the current operation.
   * @return A {@link TableResult} containing the results of executing the operation.
   * @throws StorageException if an error occurs in the storage operation.
   */
  private TableResult performMerge(
      final CloudTableClient client,
      final String tableName,
      final TableRequestOptions options,
      final OperationContext opContext)
      throws StorageException {
    Utility.assertNotNullOrEmpty("Merge requires a valid ETag", this.getEntity().getEtag());
    Utility.assertNotNullOrEmpty(
        "Merge requires a valid PartitionKey", this.getEntity().getPartitionKey());
    Utility.assertNotNullOrEmpty("Merge requires a valid RowKey", this.getEntity().getRowKey());

    final StorageOperation<CloudTableClient, TableOperation, TableResult> impl =
        new StorageOperation<CloudTableClient, TableOperation, TableResult>(options) {
          @Override
          public TableResult execute(
              final CloudTableClient client,
              final TableOperation operation,
              final OperationContext opContext)
              throws Exception {

            final HttpURLConnection request =
                TableRequest.merge(
                    client.getTransformedEndPoint(opContext),
                    tableName,
                    generateRequestIdentity(false, null, false),
                    operation.getEntity().getEtag(),
                    options.getTimeoutIntervalInMs(),
                    null,
                    options,
                    opContext);

            client.getCredentials().signRequestLite(request, -1L, opContext);

            AtomPubParser.writeSingleEntityToStream(
                operation.getEntity(), false, request.getOutputStream(), opContext);

            this.setResult(ExecutionEngine.processRequest(request, opContext));

            if (this.getResult().getStatusCode() == HttpURLConnection.HTTP_NOT_FOUND
                || this.getResult().getStatusCode() == HttpURLConnection.HTTP_CONFLICT) {
              throw TableServiceException.generateTableServiceException(
                  false, this.getResult(), operation, request.getErrorStream());
            }

            if (this.getResult().getStatusCode() == HttpURLConnection.HTTP_NO_CONTENT) {
              return operation.parseResponse(
                  null,
                  this.getResult().getStatusCode(),
                  request.getHeaderField(TableConstants.HeaderConstants.ETAG),
                  opContext);
            } else {
              throw TableServiceException.generateTableServiceException(
                  true, this.getResult(), operation, request.getErrorStream());
            }
          }
        };

    return ExecutionEngine.executeWithRetry(
        client, this, impl, options.getRetryPolicyFactory(), opContext);
  }
  /**
   * Reserved for internal use. Generates the request identity, consisting of the specified entry
   * name, or the PartitionKey and RowKey pair from the operation, to identify the operation target.
   *
   * @param isSingleIndexEntry Pass <code>true</code> to use the specified <code>entryName</code>
   *     parameter, or <code>false</code> to use PartitionKey and RowKey values from the operation
   *     as the request identity.
   * @param entryName The entry name to use as the request identity if the <code>isSingleIndexEntry
   *     </code> parameter is <code>true</code>.
   * @param encodeKeys Pass <code>true</code> to url encode the partition & row keys
   * @return A <code>String</code> containing the formatted request identity string.
   * @throws StorageException If a storage service error occurred.
   */
  protected String generateRequestIdentity(
      boolean isSingleIndexEntry, final String entryName, boolean encodeKeys)
      throws StorageException {
    if (isSingleIndexEntry) {
      return String.format("'%s'", entryName);
    }

    if (this.opType == TableOperationType.INSERT) {
      return Constants.EMPTY_STRING;
    } else {
      String pk = null;
      String rk = null;

      if (this.opType == TableOperationType.RETRIEVE) {
        final QueryTableOperation qOp = (QueryTableOperation) this;
        pk = qOp.getPartitionKey();
        rk = qOp.getRowKey();
      } else {
        pk = this.getEntity().getPartitionKey();
        rk = this.getEntity().getRowKey();
      }

      return String.format(
          "%s='%s',%s='%s'",
          TableConstants.PARTITION_KEY,
          encodeKeys ? Utility.safeEncode(pk) : pk,
          TableConstants.ROW_KEY,
          encodeKeys ? Utility.safeEncode(rk) : rk);
    }
  }
  /**
   * Reads PageRanges from the XMLStreamReader, reader must be at Start element of PageRangeElement
   *
   * @param xmlr the XMLStreamReader to read from
   * @return the PageRange from the stream.
   * @throws XMLStreamException if there is an error parsing the stream
   * @throws ParseException if there is an error in parsing a date
   * @throws URISyntaxException if the uri is invalid
   * @throws StorageException
   */
  public static ArrayList<PageRange> readPageRanges(final XMLStreamReader xmlr)
      throws XMLStreamException, StorageException {
    int eventType = xmlr.getEventType();
    final ArrayList<PageRange> retRanges = new ArrayList<PageRange>();

    xmlr.require(XMLStreamConstants.START_ELEMENT, null, BlobConstants.PAGE_RANGE_ELEMENT);

    // check if there are more events in the input stream
    while (xmlr.hasNext() && BlobConstants.PAGE_RANGE_ELEMENT.equals(xmlr.getName().toString())) {
      long startOffset = -1;
      long endOffset = -1;

      // Read a Page Range
      while (xmlr.hasNext()) {
        eventType = xmlr.next();
        final String name = xmlr.getName().toString();

        if (eventType == XMLStreamConstants.START_ELEMENT) {
          if (name.equals(BlobConstants.START_ELEMENT)) {
            final String sizeString =
                Utility.readElementFromXMLReader(xmlr, BlobConstants.START_ELEMENT);
            startOffset = Long.parseLong(sizeString);
          } else if (name.equals(Constants.END_ELEMENT)) {
            final String sizeString = Utility.readElementFromXMLReader(xmlr, Constants.END_ELEMENT);
            endOffset = Long.parseLong(sizeString);
          } else {
            throw new StorageException(
                StorageErrorCodeStrings.INVALID_XML_DOCUMENT,
                "The response received is invalid or improperly formatted.",
                Constants.HeaderConstants.HTTP_UNUSED_306,
                null,
                null);
          }
        } else if (eventType == XMLStreamConstants.END_ELEMENT) {
          if (startOffset == -1 || endOffset == -1) {
            throw new StorageException(
                StorageErrorCodeStrings.INVALID_XML_DOCUMENT,
                "The response received is invalid or improperly formatted.",
                Constants.HeaderConstants.HTTP_UNUSED_306,
                null,
                null);
          }

          final PageRange pageRef = new PageRange(startOffset, endOffset);
          retRanges.add(pageRef);
          break;
        }
      }

      eventType = xmlr.next();
    }

    return retRanges;
  }
  /**
   * Parses the input stream containing the response body of the list queues request result and
   * populates the class data.
   *
   * @param serviceClient A {@link CloudQueueClient} object associated with the storage service.
   * @throws XMLStreamException If the input stream cannot be read or parsed as a list queues
   *     response.
   * @throws StorageException
   */
  public void parseResponse(final CloudQueueClient serviceClient)
      throws XMLStreamException, StorageException {
    final XMLStreamReader xmlr = Utility.createXMLStreamReaderFromStream(this.streamRef);
    String tempParseString = null;

    // Start document
    int eventType = xmlr.getEventType();
    xmlr.require(XMLStreamConstants.START_DOCUMENT, null, null);

    // 1. get enumerationResults Header
    eventType = xmlr.next();
    xmlr.require(XMLStreamConstants.START_ELEMENT, null, "EnumerationResults");

    // check if there are more events in the input stream
    while (xmlr.hasNext()) {
      eventType = xmlr.next();

      if (eventType == XMLStreamConstants.START_ELEMENT
          || eventType == XMLStreamConstants.END_ELEMENT) {
        final String name = xmlr.getName().toString();
        if (eventType == XMLStreamConstants.START_ELEMENT
            && name.equals(Constants.MAX_RESULTS_ELEMENT)) {
          tempParseString = Utility.readElementFromXMLReader(xmlr, Constants.MAX_RESULTS_ELEMENT);
          this.maxResults = Integer.parseInt(tempParseString);
        } else if (eventType == XMLStreamConstants.START_ELEMENT
            && name.equals(Constants.MARKER_ELEMENT)) {
          this.marker = Utility.readElementFromXMLReader(xmlr, Constants.MARKER_ELEMENT);
        } else if (eventType == XMLStreamConstants.START_ELEMENT
            && name.equals(Constants.NEXT_MARKER_ELEMENT)) {
          this.nextMarker = Utility.readElementFromXMLReader(xmlr, Constants.NEXT_MARKER_ELEMENT);
        } else if (eventType == XMLStreamConstants.START_ELEMENT
            && name.equals(Constants.PREFIX_ELEMENT)) {
          this.prefix = Utility.readElementFromXMLReader(xmlr, Constants.PREFIX_ELEMENT);
        } else if (eventType == XMLStreamConstants.START_ELEMENT
            && name.equals(QueueConstants.QUEUES_ELEMENT)) {
          try {
            this.queues = QueueDeserializationHelper.readQueues(xmlr, serviceClient);
          } catch (final URISyntaxException e) {
            throw new XMLStreamException(e);
          } catch (final ParseException e) {
            throw new XMLStreamException(e);
          }

          xmlr.require(XMLStreamConstants.END_ELEMENT, null, QueueConstants.QUEUES_ELEMENT);
          // eventType = xmlr.next();
        } else if (eventType == XMLStreamConstants.END_ELEMENT
            && "EnumerationResults".equals(name)) {
          break;
        }
      }
    }

    this.isParsed = true;
  }
  /**
   * Reserved for internal use. Execute this table operation on the specified table, using the
   * specified {@link TableRequestOptions} and {@link OperationContext}.
   *
   * <p>This method will invoke the Storage Service REST API to execute this table operation, using
   * the Table service endpoint and storage account credentials in the {@link CloudTableClient}
   * object.
   *
   * @param client A {@link CloudTableClient} instance specifying the Table service endpoint,
   *     storage account credentials, and any additional query parameters.
   * @param tableName A <code>String</code> containing the name of the table.
   * @param options A {@link TableRequestOptions} object that specifies execution options such as
   *     retry policy and timeout settings for the operation.
   * @param opContext An {@link OperationContext} object for tracking the current operation.
   * @return A {@link TableResult} containing the results of executing the operation.
   * @throws StorageException if an error occurs in the storage operation.
   */
  protected TableResult execute(
      final CloudTableClient client,
      final String tableName,
      TableRequestOptions options,
      OperationContext opContext)
      throws StorageException {
    if (opContext == null) {
      opContext = new OperationContext();
    }

    if (options == null) {
      options = new TableRequestOptions();
    }

    opContext.initialize();
    options.applyDefaults(client);
    Utility.assertNotNullOrEmpty("TableName", tableName);

    if (this.getOperationType() == TableOperationType.INSERT
        || this.getOperationType() == TableOperationType.INSERT_OR_MERGE
        || this.getOperationType() == TableOperationType.INSERT_OR_REPLACE) {
      return this.performInsert(client, tableName, options, opContext);
    } else if (this.getOperationType() == TableOperationType.DELETE) {
      return this.performDelete(client, tableName, options, opContext);
    } else if (this.getOperationType() == TableOperationType.MERGE) {
      return this.performMerge(client, tableName, options, opContext);
    } else if (this.getOperationType() == TableOperationType.REPLACE) {
      return this.performUpdate(client, tableName, options, opContext);
    } else if (this.getOperationType() == TableOperationType.RETRIEVE) {
      return ((QueryTableOperation) this).performRetrieve(client, tableName, options, opContext);
    } else {
      throw new IllegalArgumentException("Unknown table operation");
    }
  }
  /**
   * Reads BlobItems from the XMLStreamReader, reader must be at Start element of BlobsElement
   *
   * @param xmlr the XMLStreamReader to read from
   * @param searchMode the block search mode
   * @return BlockEntry from the stream.
   * @throws XMLStreamException if there is an error parsing the stream
   * @throws ParseException if there is an error in parsing a date
   * @throws URISyntaxException if the uri is invalid
   * @throws StorageException
   */
  public static ArrayList<BlockEntry> readBlobBlocks(
      final XMLStreamReader xmlr, final BlockSearchMode searchMode)
      throws XMLStreamException, StorageException {
    int eventType = xmlr.getEventType();
    final ArrayList<BlockEntry> retBlocks = new ArrayList<BlockEntry>();

    xmlr.require(XMLStreamConstants.START_ELEMENT, null, BlobConstants.BLOCK_ELEMENT);

    // check if there are more events in the input stream
    while (xmlr.hasNext() && BlobConstants.BLOCK_ELEMENT.equals(xmlr.getName().toString())) {
      String blockName = null;
      long blockSize = -1;

      // Read a block
      while (xmlr.hasNext()) {
        eventType = xmlr.next();
        final String name = xmlr.getName().toString();

        if (eventType == XMLStreamConstants.START_ELEMENT) {
          if (name.equals(Constants.NAME_ELEMENT)) {
            blockName = Utility.readElementFromXMLReader(xmlr, Constants.NAME_ELEMENT);
          } else if (name.equals(BlobConstants.SIZE_ELEMENT)) {
            final String sizeString =
                Utility.readElementFromXMLReader(xmlr, BlobConstants.SIZE_ELEMENT);
            blockSize = Long.parseLong(sizeString);
          } else {
            throw new StorageException(
                StorageErrorCodeStrings.INVALID_XML_DOCUMENT,
                "The response received is invalid or improperly formatted.",
                Constants.HeaderConstants.HTTP_UNUSED_306,
                null,
                null);
          }
        } else if (eventType == XMLStreamConstants.END_ELEMENT) {
          final BlockEntry newBlock = new BlockEntry(blockName, searchMode);
          newBlock.setSize(blockSize);
          retBlocks.add(newBlock);
          break;
        }
      }

      eventType = xmlr.next();
    }

    return retBlocks;
  }
 /**
  * Uploads a new configuration of service properties to the storage service, using the specified
  * request options and operation context. This includes Metrics and Logging Configuration.
  *
  * @param properties The {@link ServiceProperties} to upload.
  * @param options A {@link RequestOptions} object that specifies any additional options for the
  *     request. Specifying <code>null</code> will use the default request options from the
  *     associated service client ( {@link CloudBlobClient}{@link CloudQueueClient}).
  * @param opContext An {@link OperationContext} object that represents the context for the current
  *     operation. This object is used to track requests to the storage service, and to provide
  *     additional runtime information about the operation.
  * @throws StorageException If a storage service error occurred during the operation.
  */
 @DoesServiceRequest
 @Override
 public void uploadServiceProperties(
     final ServiceProperties properties,
     final RequestOptions options,
     final OperationContext opContext)
     throws StorageException {
   if (!Utility.isNullOrEmpty(properties.getDefaultServiceVersion())) {
     throw new IllegalArgumentException(
         "DefaultServiceVersion can only be set for the Blob service and the request must be made using the 2011-08-18 version");
   }
   super.uploadServiceProperties(properties, options, opContext);
 }
  /**
   * Gets a result segment containing a collection of queues from the storage service with the
   * specified parameters.
   *
   * @param prefix A <code>String</code> containing the queue name prefix to filter the results
   *     with.
   * @param detailsIncluded A {@link QueueListingDetails} value that indicates whether queue
   *     metadata will be returned.
   * @param maxResults The maximum number of queue results to retrieve.
   * @param continuationToken A {@link ResultContinuation} object that represents a continuation
   *     token returned by a previous listing operation.
   * @param options A {@link QueueRequestOptions} object that specifies any additional options for
   *     the request. Specifying <code>null</code> will use the default request options from the
   *     associated service client ( {@link CloudQueue}).
   * @param taskReference A {@link StorageOperation} reference to the encapsulating task.
   * @param opContext An {@link OperationContext} object that represents the context for the current
   *     operation. This object is used to track requests to the storage service, and to provide
   *     additional runtime information about the operation.
   * @return A {@link ResultSegment} of {@link CloudQueue} objects that contains a segment of the
   *     iterable collection of {@link CloudQueue} objects that represent the requested queues in
   *     the storage service.
   * @throws IOException
   * @throws URISyntaxException If the URI is not valid.
   * @throws XMLStreamException
   * @throws InvalidKeyException
   * @throws StorageException If a storage service error occurred during the operation.
   */
  @DoesServiceRequest
  ResultSegment<CloudQueue> listQueuesCore(
      final String prefix,
      final QueueListingDetails detailsIncluded,
      final int maxResults,
      final ResultContinuation continuationToken,
      final RequestOptions options,
      final StorageOperation<CloudQueueClient, Void, ResultSegment<CloudQueue>> taskReference,
      final OperationContext opContext)
      throws IOException, URISyntaxException, XMLStreamException, InvalidKeyException,
          StorageException {

    Utility.assertContinuationType(continuationToken, ResultContinuationType.QUEUE);

    final ListingContext listingContext = new ListingContext(prefix, maxResults);
    listingContext.setMarker(continuationToken != null ? continuationToken.getNextMarker() : null);

    final HttpURLConnection listQueueRequest =
        QueueRequest.list(
            this.getEndpoint(),
            options.getTimeoutIntervalInMs(),
            listingContext,
            detailsIncluded,
            opContext);

    this.getCredentials().signRequest(listQueueRequest, -1L);

    taskReference.setResult(ExecutionEngine.processRequest(listQueueRequest, opContext));

    if (taskReference.getResult().getStatusCode() != HttpURLConnection.HTTP_OK) {
      taskReference.setNonExceptionedRetryableFailure(true);
      return null;
    }

    final ListQueuesResponse response = new ListQueuesResponse(listQueueRequest.getInputStream());
    response.parseResponse(this);

    ResultContinuation newToken = null;

    if (response.getNextMarker() != null) {
      newToken = new ResultContinuation();
      newToken.setNextMarker(response.getNextMarker());
      newToken.setContinuationType(ResultContinuationType.QUEUE);
    }

    final ResultSegment<CloudQueue> resSegment =
        new ResultSegment<CloudQueue>(response.getQueues(this), maxResults, newToken);

    return resSegment;
  }
  /**
   * Populates the CloudBlobDirectory from an XMLStreamReader, reader must be at Start element of
   * BlobPrefix
   *
   * @param xmlr the XMLStreamReader to read from
   * @param serviceClient the CloudBlobClient associated with the objects.
   * @param container the container associated with the objects.
   * @return a CloudBlobDirectory parsed from the stream.
   * @throws XMLStreamException if there is an error parsing the stream
   * @throws ParseException if there is an error in parsing a date
   * @throws URISyntaxException if the uri is invalid
   * @throws StorageException
   */
  protected static CloudBlobDirectory readDirectory(
      final XMLStreamReader xmlr,
      final CloudBlobClient serviceClient,
      final CloudBlobContainer container)
      throws XMLStreamException, ParseException, URISyntaxException, StorageException {
    xmlr.require(XMLStreamConstants.START_ELEMENT, null, BlobConstants.BLOB_PREFIX_ELEMENT);

    // Move to Name element
    xmlr.next();
    xmlr.require(XMLStreamConstants.START_ELEMENT, null, Constants.NAME_ELEMENT);

    final String prefixName = Utility.readElementFromXMLReader(xmlr, Constants.NAME_ELEMENT);

    // Move from End name element to end prefix element
    xmlr.next();
    xmlr.require(XMLStreamConstants.END_ELEMENT, null, BlobConstants.BLOB_PREFIX_ELEMENT);

    return container.getDirectoryReference(prefixName);
  }
  /**
   * Gets a result segment of an iterable collection of queues whose names begin with the specified
   * prefix for this queue, using the specified listing details options, request options, and
   * operation context.
   *
   * @param prefix A <code>String</code> that represents the prefix of the queue name to match.
   * @param detailsIncluded A {@link QueueListingDetails} value that indicates whether queue
   *     metadata will be returned.
   * @param maxResults The maximum number of queue results to retrieve.
   * @param continuationToken A {@link ResultContinuation} object that represents a continuation
   *     token returned by a previous listing operation.
   * @param options A {@link QueueRequestOptions} object that specifies any additional options for
   *     the request. Specifying <code>null</code> will use the default request options from the
   *     associated service client ( {@link CloudQueue}).
   * @param opContext An {@link OperationContext} object that represents the context for the current
   *     operation. This object is used to track requests to the storage service, and to provide
   *     additional runtime information about the operation.
   * @return A {@link ResultSegment} of {@link CloudQueue} objects that contains a segment of the
   *     iterable collection of {@link CloudQueue} objects that represent the requested queues in
   *     the storage service.
   * @throws StorageException If a storage service error occurred during the operation.
   */
  @DoesServiceRequest
  public ResultSegment<CloudQueue> listQueuesSegmented(
      final String prefix,
      final QueueListingDetails detailsIncluded,
      final int maxResults,
      final ResultContinuation continuationToken,
      QueueRequestOptions options,
      OperationContext opContext)
      throws StorageException {

    if (opContext == null) {
      opContext = new OperationContext();
    }

    if (options == null) {
      options = new QueueRequestOptions();
    }

    opContext.initialize();
    options.applyDefaults(this);

    Utility.assertContinuationType(continuationToken, ResultContinuationType.QUEUE);

    final StorageOperation<CloudQueueClient, Void, ResultSegment<CloudQueue>> impl =
        new StorageOperation<CloudQueueClient, Void, ResultSegment<CloudQueue>>(options) {
          @Override
          public ResultSegment<CloudQueue> execute(
              final CloudQueueClient client, final Void dontCare, final OperationContext opContext)
              throws Exception {
            return CloudQueueClient.this.listQueuesCore(
                prefix,
                detailsIncluded,
                maxResults,
                continuationToken,
                this.getRequestOptions(),
                this,
                opContext);
          }
        };

    return ExecutionEngine.executeWithRetry(
        this, null, impl, options.getRetryPolicyFactory(), opContext);
  }
示例#12
0
  /**
   * Writes a Block List and returns the corresponding UTF8 bytes.
   *
   * @param blockList the Iterable of BlockEntry to write
   * @param opContext a tracking object for the request
   * @return a byte array of the UTF8 bytes representing the serialized block list.
   * @throws XMLStreamException if there is an error writing the block list.
   * @throws StorageException
   */
  public static byte[] writeBlockListToStream(
      final Iterable<BlockEntry> blockList, final OperationContext opContext)
      throws XMLStreamException, StorageException {

    final StringWriter outWriter = new StringWriter();
    final XMLOutputFactory xmlOutFactoryInst = XMLOutputFactory.newInstance();
    final XMLStreamWriter xmlw = xmlOutFactoryInst.createXMLStreamWriter(outWriter);

    // default is UTF8
    xmlw.writeStartDocument();
    xmlw.writeStartElement(BlobConstants.BLOCK_LIST_ELEMENT);

    for (final BlockEntry block : blockList) {
      if (block.searchMode == BlockSearchMode.COMMITTED) {
        xmlw.writeStartElement(BlobConstants.COMMITTED_ELEMENT);
      } else if (block.searchMode == BlockSearchMode.UNCOMMITTED) {
        xmlw.writeStartElement(BlobConstants.UNCOMMITTED_ELEMENT);
      } else if (block.searchMode == BlockSearchMode.LATEST) {
        xmlw.writeStartElement(BlobConstants.LATEST_ELEMENT);
      }

      xmlw.writeCharacters(block.getId());
      xmlw.writeEndElement();
    }

    // end BlockListElement
    xmlw.writeEndElement();

    // end doc
    xmlw.writeEndDocument();
    try {
      return outWriter.toString().getBytes("UTF8");
    } catch (final UnsupportedEncodingException e) {
      throw Utility.generateNewUnexpectedStorageException(e);
    }
  }
  /**
   * Populates the object from the XMLStreamReader, reader must be at Start element of Properties
   *
   * @param xmlr the XMLStreamReader object
   * @throws XMLStreamException if there is a parsing exception
   * @throws ParseException if a date value is not correctly encoded
   */
  protected static BlobContainerProperties readBlobContainerProperties(final XMLStreamReader xmlr)
      throws XMLStreamException, ParseException {
    xmlr.require(XMLStreamConstants.START_ELEMENT, null, BlobConstants.PROPERTIES);
    int eventType = xmlr.getEventType();
    final BlobContainerProperties properties = new BlobContainerProperties();

    while (xmlr.hasNext()) {
      eventType = xmlr.next();
      final String name = xmlr.getName().toString();
      if (eventType == XMLStreamConstants.START_ELEMENT) {
        if (name.equals(Constants.LAST_MODIFIED_ELEMENT)) {
          properties.setLastModified(
              Utility.parseRFC1123DateFromStringInGMT(
                  Utility.readElementFromXMLReader(xmlr, Constants.LAST_MODIFIED_ELEMENT)));
        } else if (name.equals(Constants.ETAG_ELEMENT)) {
          properties.setEtag(Utility.readElementFromXMLReader(xmlr, Constants.ETAG_ELEMENT));
        } else if (name.equals(Constants.LEASE_STATUS_ELEMENT)) {
          properties.setLeaseStatus(
              LeaseStatus.parse(
                  Utility.readElementFromXMLReader(xmlr, Constants.LEASE_STATUS_ELEMENT)));
        } else if (name.equals(Constants.LEASE_STATE_ELEMENT)) {
          properties.setLeaseState(
              LeaseState.parse(
                  Utility.readElementFromXMLReader(xmlr, Constants.LEASE_STATE_ELEMENT)));
        } else if (name.equals(Constants.LEASE_DURATION_ELEMENT)) {
          properties.setLeaseDuration(
              LeaseDuration.parse(
                  Utility.readElementFromXMLReader(xmlr, Constants.LEASE_DURATION_ELEMENT)));
        }
      } else {
        // expect end of properties
        xmlr.require(XMLStreamConstants.END_ELEMENT, null, BlobConstants.PROPERTIES);
        break;
      }
    }

    return properties;
  }
 /**
  * A static factory method returning a {@link TableOperation} instance to replace the specified
  * entity in Windows Azure storage, or insert it if it does not exist. To execute this {@link
  * TableOperation} on a given table, call the {@link CloudTableClient#execute(String,
  * TableOperation)} method on a {@link CloudTableClient} instance with the table name and the
  * {@link TableOperation} as arguments.
  *
  * @param entity The object instance implementing {@link TableEntity} to associate with the
  *     operation.
  * @return A new {@link TableOperation} instance for inserting or replacing the table entity.
  */
 public static TableOperation insertOrReplace(final TableEntity entity) {
   Utility.assertNotNull("Entity", entity);
   return new TableOperation(entity, TableOperationType.INSERT_OR_REPLACE);
 }
 /**
  * A static factory method returning a {@link TableOperation} instance to merge the specified
  * entity into Windows Azure storage, or insert it if it does not exist. To execute this {@link
  * TableOperation} on a given table, call the {@link CloudTableClient#execute(String,
  * TableOperation)} method on a {@link CloudTableClient} instance with the table name and the
  * {@link TableOperation} as arguments.
  *
  * @param entity The object instance implementing {@link TableEntity} to associate with the
  *     operation.
  * @return A new {@link TableOperation} instance for inserting or merging the table entity.
  */
 public static TableOperation insertOrMerge(final TableEntity entity) {
   Utility.assertNotNull("Entity", entity);
   return new TableOperation(entity, TableOperationType.INSERT_OR_MERGE);
 }
 /**
  * A static factory method returning a {@link TableOperation} instance to delete the specified
  * entity from Windows Azure storage. To execute this {@link TableOperation} on a given table,
  * call the {@link CloudTableClient#execute(String, TableOperation)} method on a {@link
  * CloudTableClient} instance with the table name and the {@link TableOperation} as arguments.
  *
  * @param entity The object instance implementing {@link TableEntity} to associate with the
  *     operation.
  * @return A new {@link TableOperation} instance to insert the table entity.
  */
 public static TableOperation delete(final TableEntity entity) {
   Utility.assertNotNull("Entity", entity);
   Utility.assertNotNullOrEmpty("Entity Etag", entity.getEtag());
   return new TableOperation(entity, TableOperationType.DELETE);
 }
  /**
   * Reserved for internal use. Performs an insert operation on the specified table, using the
   * specified {@link TableRequestOptions} and {@link OperationContext}.
   *
   * <p>This method will invoke the Insert Entity REST API to execute this table operation, using
   * the Table service endpoint and storage account credentials in the {@link CloudTableClient}
   * object.
   *
   * @param client A {@link CloudTableClient} instance specifying the Table service endpoint,
   *     storage account credentials, and any additional query parameters.
   * @param tableName A <code>String</code> containing the name of the table.
   * @param options A {@link TableRequestOptions} object that specifies execution options such as
   *     retry policy and timeout settings for the operation.
   * @param opContext An {@link OperationContext} object for tracking the current operation.
   * @return A {@link TableResult} containing the results of executing the operation.
   * @throws StorageException if an error occurs in the storage operation.
   */
  private TableResult performInsert(
      final CloudTableClient client,
      final String tableName,
      final TableRequestOptions options,
      final OperationContext opContext)
      throws StorageException {
    final boolean isTableEntry = TableConstants.TABLES_SERVICE_TABLES_NAME.equals(tableName);
    final String tableIdentity =
        isTableEntry
            ? this.getEntity()
                .writeEntity(opContext)
                .get(TableConstants.TABLE_NAME)
                .getValueAsString()
            : null;

    // Upserts need row key and partition key
    if (!isTableEntry && this.opType != TableOperationType.INSERT) {
      Utility.assertNotNullOrEmpty(
          "Upserts require a valid PartitionKey", this.getEntity().getPartitionKey());
      Utility.assertNotNullOrEmpty("Upserts require a valid RowKey", this.getEntity().getRowKey());
    }

    final StorageOperation<CloudTableClient, TableOperation, TableResult> impl =
        new StorageOperation<CloudTableClient, TableOperation, TableResult>(options) {
          @Override
          public TableResult execute(
              final CloudTableClient client,
              final TableOperation operation,
              final OperationContext opContext)
              throws Exception {
            final HttpURLConnection request =
                TableRequest.insert(
                    client.getTransformedEndPoint(opContext),
                    tableName,
                    generateRequestIdentity(isTableEntry, tableIdentity, false),
                    operation.opType != TableOperationType.INSERT
                        ? operation.getEntity().getEtag()
                        : null,
                    operation.opType.getUpdateType(),
                    options.getTimeoutIntervalInMs(),
                    null,
                    options,
                    opContext);

            client.getCredentials().signRequestLite(request, -1L, opContext);

            AtomPubParser.writeSingleEntityToStream(
                operation.getEntity(), isTableEntry, request.getOutputStream(), opContext);

            this.setResult(ExecutionEngine.processRequest(request, opContext));
            if (operation.opType == TableOperationType.INSERT) {
              if (this.getResult().getStatusCode() == HttpURLConnection.HTTP_CONFLICT) {
                throw TableServiceException.generateTableServiceException(
                    false, this.getResult(), operation, request.getErrorStream());
              }

              if (this.getResult().getStatusCode() != HttpURLConnection.HTTP_CREATED) {
                throw TableServiceException.generateTableServiceException(
                    true, this.getResult(), operation, request.getErrorStream());
              }

              InputStream inStream = request.getInputStream();
              TableResult res = null;

              try {
                final XMLStreamReader xmlr = Utility.createXMLStreamReaderFromStream(inStream);
                res =
                    operation.parseResponse(
                        xmlr, this.getResult().getStatusCode(), null, opContext);
              } finally {
                inStream.close();
              }

              return res;
            } else {
              if (this.getResult().getStatusCode() == HttpURLConnection.HTTP_NO_CONTENT) {
                return operation.parseResponse(
                    null,
                    this.getResult().getStatusCode(),
                    request.getHeaderField(TableConstants.HeaderConstants.ETAG),
                    opContext);
              } else {
                throw TableServiceException.generateTableServiceException(
                    true, this.getResult(), operation, request.getErrorStream());
              }
            }
          }
        };

    return ExecutionEngine.executeWithRetry(
        client, this, impl, options.getRetryPolicyFactory(), opContext);
  }
  /**
   * Populates the object from the XMLStreamReader, reader must be at Start element of Properties
   *
   * @param xmlr the XMLStreamReader object
   * @return the BlobProperties that was read.
   * @throws XMLStreamException if there is a parsing exception
   * @throws ParseException if a date value is not correctly encoded
   * @throws StorageException
   * @throws URISyntaxException
   */
  protected static BlobProperties readBlobProperties(final XMLStreamReader xmlr)
      throws XMLStreamException, ParseException, StorageException, URISyntaxException {
    xmlr.require(XMLStreamConstants.START_ELEMENT, null, BlobConstants.PROPERTIES);
    int eventType = xmlr.getEventType();
    final BlobProperties properties = new BlobProperties();

    while (xmlr.hasNext()) {
      eventType = xmlr.next();
      final String name = xmlr.getName().toString();

      if (eventType == XMLStreamConstants.START_ELEMENT) {
        if (name.equals(Constants.LAST_MODIFIED_ELEMENT)) {
          properties.setLastModified(
              Utility.parseRFC1123DateFromStringInGMT(
                  Utility.readElementFromXMLReader(xmlr, Constants.LAST_MODIFIED_ELEMENT)));
        } else if (name.equals(Constants.ETAG_ELEMENT)) {
          properties.setEtag(Utility.readElementFromXMLReader(xmlr, Constants.ETAG_ELEMENT));
        } else if (name.equals(Constants.HeaderConstants.CONTENT_LENGTH)) {
          final String tempString =
              Utility.readElementFromXMLReader(xmlr, Constants.HeaderConstants.CONTENT_LENGTH);
          properties.setLength(Long.parseLong(tempString));
        } else if (name.equals(Constants.HeaderConstants.CONTENT_TYPE)) {
          properties.setContentType(
              Utility.readElementFromXMLReader(xmlr, Constants.HeaderConstants.CONTENT_TYPE));
        } else if (name.equals(Constants.HeaderConstants.CONTENT_ENCODING)) {
          properties.setContentEncoding(
              Utility.readElementFromXMLReader(xmlr, Constants.HeaderConstants.CONTENT_ENCODING));
        } else if (name.equals(Constants.HeaderConstants.CONTENT_LANGUAGE)) {
          properties.setContentLanguage(
              Utility.readElementFromXMLReader(xmlr, Constants.HeaderConstants.CONTENT_LANGUAGE));
        } else if (name.equals(Constants.HeaderConstants.CONTENT_MD5)) {
          properties.setContentMD5(
              Utility.readElementFromXMLReader(xmlr, Constants.HeaderConstants.CONTENT_MD5));
        } else if (name.equals(Constants.HeaderConstants.CACHE_CONTROL)) {
          properties.setCacheControl(
              Utility.readElementFromXMLReader(xmlr, Constants.HeaderConstants.CACHE_CONTROL));
        } else if (name.equals(Constants.HeaderConstants.CACHE_CONTROL)) {
          properties.setCacheControl(
              Utility.readElementFromXMLReader(xmlr, Constants.HeaderConstants.CACHE_CONTROL));
        } else if (name.equals(BlobConstants.SEQUENCE_NUMBER)) {
          Utility.readElementFromXMLReader(xmlr, BlobConstants.SEQUENCE_NUMBER);
        } else if (name.equals(BlobConstants.BLOB_TYPE_ELEMENT)) {
          final String tempString =
              Utility.readElementFromXMLReader(xmlr, BlobConstants.BLOB_TYPE_ELEMENT);
          if (tempString.equals(BlobConstants.BLOCK_BLOB_VALUE)) {
            properties.setBlobType(BlobType.BLOCK_BLOB);
          } else if (tempString.equals(BlobConstants.PAGE_BLOB_VALUE)) {
            properties.setBlobType(BlobType.PAGE_BLOB);
          } else {
            throw new StorageException(
                StorageErrorCodeStrings.INVALID_XML_DOCUMENT,
                "The response received is invalid or improperly formatted.",
                Constants.HeaderConstants.HTTP_UNUSED_306,
                null,
                null);
          }
        } else if (name.equals(Constants.LEASE_STATUS_ELEMENT)) {
          final String tempString =
              Utility.readElementFromXMLReader(xmlr, Constants.LEASE_STATUS_ELEMENT);
          if (tempString.equals(Constants.LOCKED_VALUE.toLowerCase())) {
            properties.setLeaseStatus(LeaseStatus.LOCKED);
          } else if (tempString.equals(Constants.UNLOCKED_VALUE.toLowerCase())) {
            properties.setLeaseStatus(LeaseStatus.UNLOCKED);
          } else {
            throw new StorageException(
                StorageErrorCodeStrings.INVALID_XML_DOCUMENT,
                "The response received is invalid or improperly formatted.",
                Constants.HeaderConstants.HTTP_UNUSED_306,
                null,
                null);
          }
        } else if (name.equals(Constants.LEASE_STATE_ELEMENT)) {
          properties.setLeaseState(
              LeaseState.parse(
                  Utility.readElementFromXMLReader(xmlr, Constants.LEASE_STATE_ELEMENT)));
        } else if (name.equals(Constants.LEASE_DURATION_ELEMENT)) {
          properties.setLeaseDuration(
              LeaseDuration.parse(
                  Utility.readElementFromXMLReader(xmlr, Constants.LEASE_DURATION_ELEMENT)));
        }
      } else if (eventType == XMLStreamConstants.END_ELEMENT) {
        // expect end of properties
        xmlr.require(XMLStreamConstants.END_ELEMENT, null, BlobConstants.PROPERTIES);
        break;
      }
    }

    return properties;
  }
  /**
   * Reserved for internal use. Performs a delete operation on the specified table, using the
   * specified {@link TableRequestOptions} and {@link OperationContext}.
   *
   * <p>This method will invoke the <a
   * href="http://msdn.microsoft.com/en-us/library/windowsazure/dd135727.aspx">Delete Entity</a>
   * REST API to execute this table operation, using the Table service endpoint and storage account
   * credentials in the {@link CloudTableClient} object.
   *
   * @param client A {@link CloudTableClient} instance specifying the Table service endpoint,
   *     storage account credentials, and any additional query parameters.
   * @param tableName A <code>String</code> containing the name of the table.
   * @param options A {@link TableRequestOptions} object that specifies execution options such as
   *     retry policy and timeout settings for the operation.
   * @param opContext An {@link OperationContext} object for tracking the current operation.
   * @return A {@link TableResult} containing the results of executing the operation.
   * @throws StorageException if an error occurs in the storage operation.
   */
  private TableResult performDelete(
      final CloudTableClient client,
      final String tableName,
      final TableRequestOptions options,
      final OperationContext opContext)
      throws StorageException {
    final boolean isTableEntry = TableConstants.TABLES_SERVICE_TABLES_NAME.equals(tableName);
    final String tableIdentity =
        isTableEntry
            ? this.getEntity()
                .writeEntity(opContext)
                .get(TableConstants.TABLE_NAME)
                .getValueAsString()
            : null;

    if (!isTableEntry) {
      Utility.assertNotNullOrEmpty("Delete requires a valid ETag", this.getEntity().getEtag());
      Utility.assertNotNullOrEmpty(
          "Delete requires a valid PartitionKey", this.getEntity().getPartitionKey());
      Utility.assertNotNullOrEmpty("Delete requires a valid RowKey", this.getEntity().getRowKey());
    }

    final StorageOperation<CloudTableClient, TableOperation, TableResult> impl =
        new StorageOperation<CloudTableClient, TableOperation, TableResult>(options) {
          @Override
          public TableResult execute(
              final CloudTableClient client,
              final TableOperation operation,
              final OperationContext opContext)
              throws Exception {

            final HttpURLConnection request =
                TableRequest.delete(
                    client.getTransformedEndPoint(opContext),
                    tableName,
                    generateRequestIdentity(isTableEntry, tableIdentity, false),
                    operation.getEntity().getEtag(),
                    options.getTimeoutIntervalInMs(),
                    null,
                    options,
                    opContext);

            client.getCredentials().signRequestLite(request, -1L, opContext);

            this.setResult(ExecutionEngine.processRequest(request, opContext));

            if (this.getResult().getStatusCode() == HttpURLConnection.HTTP_NOT_FOUND
                || this.getResult().getStatusCode() == HttpURLConnection.HTTP_CONFLICT) {
              throw TableServiceException.generateTableServiceException(
                  false, this.getResult(), operation, request.getErrorStream());
            }

            if (this.getResult().getStatusCode() != HttpURLConnection.HTTP_NO_CONTENT) {
              throw TableServiceException.generateTableServiceException(
                  true, this.getResult(), operation, request.getErrorStream());
            }

            return operation.parseResponse(null, this.getResult().getStatusCode(), null, opContext);
          }
        };

    return ExecutionEngine.executeWithRetry(
        client, this, impl, options.getRetryPolicyFactory(), opContext);
  }
 /**
  * A static factory method returning a {@link TableOperation} instance to replace the specified
  * table entity. To execute this {@link TableOperation} on a given table, call the {@link
  * CloudTableClient#execute(String, TableOperation)} method on a {@link CloudTableClient} instance
  * with the table name and the {@link TableOperation} as arguments.
  *
  * @param entity The object instance implementing {@link TableEntity} to associate with the
  *     operation.
  * @return A new {@link TableOperation} instance for replacing the table entity.
  */
 public static TableOperation replace(final TableEntity entity) {
   Utility.assertNotNullOrEmpty("Entity Etag", entity.getEtag());
   return new TableOperation(entity, TableOperationType.REPLACE);
 }
 /**
  * Gets a {@link CloudQueue} object that represents the storage service queue for the specified
  * address.
  *
  * @param queueAddress A <code>String</code> that represents the name of the queue, or the
  *     absolute URI to the queue.
  * @return A {@link CloudQueue} object that represents a reference to the queue.
  * @throws URISyntaxException If the resource URI is invalid.
  * @throws StorageException If a storage service error occurred during the operation.
  */
 public CloudQueue getQueueReference(final String queueAddress)
     throws URISyntaxException, StorageException {
   Utility.assertNotNullOrEmpty("queueAddress", queueAddress);
   return new CloudQueue(queueAddress, this);
 }
  /**
   * Reserved for internal use. Populates the blob from an XMLStreamReader, reader must be at Start
   * element of Blob
   *
   * @param xmlr the XMLStreamReader to read from
   * @param serviceClient the CloudBlobClient associated with the objects.
   * @throws XMLStreamException if there is an error parsing the stream
   * @throws ParseException if there is an error in parsing a date
   * @throws URISyntaxException if the uri is invalid
   * @throws StorageException
   */
  protected static CloudBlob readBlob(
      final XMLStreamReader xmlr,
      final CloudBlobClient serviceClient,
      final CloudBlobContainer container)
      throws XMLStreamException, ParseException, URISyntaxException, StorageException {
    xmlr.require(XMLStreamConstants.START_ELEMENT, null, BlobConstants.BLOB_ELEMENT);

    String blobName = Constants.EMPTY_STRING;

    String snapshotID = null;
    String urlString = null;
    HashMap<String, String> metadata = null;
    BlobProperties properties = null;
    CopyState copyState = null;

    int eventType = xmlr.getEventType();
    // check if there are more events in the input stream
    while (xmlr.hasNext()) {
      eventType = xmlr.next();
      final String name = xmlr.getName().toString();

      if (eventType == XMLStreamConstants.START_ELEMENT) {
        if (name.equals(Constants.URL_ELEMENT)) {
          urlString = Utility.readElementFromXMLReader(xmlr, Constants.URL_ELEMENT);
        } else if (name.equals(BlobConstants.SNAPSHOT_ELEMENT)) {
          snapshotID = Utility.readElementFromXMLReader(xmlr, BlobConstants.SNAPSHOT_ELEMENT);
        } else if (name.equals(Constants.NAME_ELEMENT)) {
          blobName = Utility.readElementFromXMLReader(xmlr, Constants.NAME_ELEMENT);
        } else if (name.equals(BlobConstants.PROPERTIES)) {
          properties = BlobDeserializationHelper.readBlobProperties(xmlr);
          xmlr.require(XMLStreamConstants.END_ELEMENT, null, BlobConstants.PROPERTIES);
        } else if (name.equals(Constants.METADATA_ELEMENT)) {
          metadata = DeserializationHelper.parseMetadateFromXML(xmlr);
          xmlr.require(XMLStreamConstants.END_ELEMENT, null, Constants.METADATA_ELEMENT);
        } else if (name.equals(Constants.COPY_ID_ELEMENT)) {
          if (copyState == null) {
            copyState = new CopyState();
          }
          copyState.setCopyId(Utility.readElementFromXMLReader(xmlr, Constants.COPY_ID_ELEMENT));
        } else if (name.equals(Constants.COPY_COMPLETION_TIME_ELEMENT)) {
          if (copyState == null) {
            copyState = new CopyState();
          }
          copyState.setCompletionTime(
              Utility.parseRFC1123DateFromStringInGMT(
                  Utility.readElementFromXMLReader(xmlr, Constants.COPY_COMPLETION_TIME_ELEMENT)));
        } else if (name.equals(Constants.COPY_STATUS_ELEMENT)) {
          if (copyState == null) {
            copyState = new CopyState();
          }
          copyState.setStatus(
              CopyStatus.parse(
                  Utility.readElementFromXMLReader(xmlr, Constants.COPY_STATUS_ELEMENT)));
        } else if (name.equals(Constants.COPY_SOURCE_ELEMENT)) {
          if (copyState == null) {
            copyState = new CopyState();
          }
          copyState.setSource(
              new URI(Utility.readElementFromXMLReader(xmlr, Constants.COPY_SOURCE_ELEMENT)));
        } else if (name.equals(Constants.COPY_PROGRESS_ELEMENT)) {
          if (copyState == null) {
            copyState = new CopyState();
          }

          final String tempString =
              Utility.readElementFromXMLReader(xmlr, Constants.COPY_PROGRESS_ELEMENT);
          String[] progressSequence = tempString.split("/");
          copyState.setBytesCopied(Long.parseLong(progressSequence[0]));
          copyState.setTotalBytes(Long.parseLong(progressSequence[1]));
        } else if (name.equals(Constants.COPY_STATUS_DESCRIPTION_ELEMENT)) {
          if (copyState == null) {
            copyState = new CopyState();
          }
          copyState.setStatusDescription(
              Utility.readElementFromXMLReader(xmlr, Constants.COPY_STATUS_DESCRIPTION_ELEMENT));
        }
      } else if (eventType == XMLStreamConstants.END_ELEMENT
          && name.equals(BlobConstants.BLOB_ELEMENT)) {
        break;
      }
    }

    xmlr.require(XMLStreamConstants.END_ELEMENT, null, BlobConstants.BLOB_ELEMENT);

    // Assemble and return
    if (properties != null) {
      CloudBlob retBlob = null;
      final int blobNameSectionIndex = urlString.lastIndexOf("/".concat(blobName));
      final URI baseUri = new URI(urlString.substring(0, blobNameSectionIndex + 1));
      String query = null;
      if (blobNameSectionIndex + 1 + blobName.length() < urlString.length()) {
        // Snapshot blob URI
        // example:http://<yourstorageaccount>.blob.core.windows.net/<yourcontainer>/<yourblobname>?snapshot=2009-12-03T15%3a26%3a19.4466877Z
        query = urlString.substring(blobNameSectionIndex + 1 + blobName.length() + 1);
      }

      final URI blobURI =
          new URI(
              baseUri.getScheme(),
              baseUri.getAuthority(),
              baseUri.getRawPath().concat(blobName),
              query,
              null);

      if (properties.getBlobType() == BlobType.BLOCK_BLOB) {
        retBlob = new CloudBlockBlob(blobURI, serviceClient, container);
      } else if (properties.getBlobType() == BlobType.PAGE_BLOB) {
        retBlob = new CloudPageBlob(blobURI, serviceClient, container);
      } else {
        throw new StorageException(
            StorageErrorCodeStrings.INVALID_XML_DOCUMENT,
            "The response received is invalid or improperly formatted.",
            Constants.HeaderConstants.HTTP_UNUSED_306,
            null,
            null);
      }

      retBlob.uri = blobURI;
      retBlob.snapshotID = snapshotID;
      retBlob.properties = properties;
      retBlob.metadata = metadata;
      retBlob.copyState = copyState;
      return retBlob;
    } else {
      throw new StorageException(
          StorageErrorCodeStrings.INVALID_XML_DOCUMENT,
          "The response received is invalid or improperly formatted.",
          Constants.HeaderConstants.HTTP_UNUSED_306,
          null,
          null);
    }
  }
示例#23
0
  /**
   * Constructs a HttpURLConnection to list blobs. Sign with no length specified.
   *
   * @param uri The absolute URI to the blob
   * @param timeout The server timeout interval
   * @param listingContext A set of parameters for the listing operation.
   * @param blobOptions the options to use for the request.
   * @param opContext a tracking object for the request
   * @return a HttpURLConnection configured for the operation.
   * @throws IOException if there is an error opening the connection
   * @throws URISyntaxException if the resource URI is invalid
   * @throws StorageException an exception representing any error which occurred during the
   *     operation.
   * @throws IllegalArgumentException
   */
  public static HttpURLConnection list(
      final URI uri,
      final int timeout,
      final BlobListingContext listingContext,
      final BlobRequestOptions blobOptions,
      final OperationContext opContext)
      throws URISyntaxException, IOException, StorageException {

    final UriQueryBuilder builder = ContainerRequest.getContainerUriQueryBuilder();
    builder.add("comp", "list");

    if (listingContext != null) {
      if (!Utility.isNullOrEmpty(listingContext.getPrefix())) {
        builder.add("prefix", listingContext.getPrefix());
      }

      if (!Utility.isNullOrEmpty(listingContext.getDelimiter())) {
        builder.add("delimiter", listingContext.getDelimiter());
      }

      if (!Utility.isNullOrEmpty(listingContext.getMarker())) {
        builder.add("marker", listingContext.getMarker());
      }

      if (listingContext.getMaxResults() != null && listingContext.getMaxResults() > 0) {
        builder.add("maxresults", listingContext.getMaxResults().toString());
      }

      if (listingContext.getListingDetails().size() > 0) {
        final StringBuilder sb = new StringBuilder();

        boolean started = false;

        if (listingContext.getListingDetails().contains(BlobListingDetails.SNAPSHOTS)) {
          if (!started) {
            started = true;
          } else {
            sb.append(",");
          }

          sb.append("snapshots");
        }

        if (listingContext.getListingDetails().contains(BlobListingDetails.UNCOMMITTED_BLOBS)) {
          if (!started) {
            started = true;
          } else {
            sb.append(",");
          }

          sb.append("uncommittedblobs");
        }

        if (listingContext.getListingDetails().contains(BlobListingDetails.METADATA)) {
          if (!started) {
            started = true;
          } else {
            sb.append(",");
          }

          sb.append("metadata");
        }

        builder.add("include", sb.toString());
      }
    }

    final HttpURLConnection request =
        BlobRequest.createURLConnection(uri, timeout, builder, blobOptions, opContext);

    request.setRequestMethod("GET");

    return request;
  }