Example #1
0
        public string getConfigXML()
        {
            string retVal = client.Get("config") as string;
              if(retVal == null || retVal == string.Empty )
              {
            string diagnosticsConnection = RoleEnvironment.GetConfigurationSettingValue("Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString");
            string azureAccount = string.Empty;
            string azureEndpoint = string.Empty;
            string azureSharedKey = string.Empty;
            string defaultEndpointsProtocol = string.Empty;

            foreach (string item in diagnosticsConnection.Split(";".ToCharArray()))
            {
              string[] parsedItem = item.Split("=".ToCharArray());
              switch (parsedItem[0])
              {
            case "AccountKey": azureSharedKey = parsedItem[1];
              for (int i = 2; i < parsedItem.Length; i++)
                azureSharedKey += "=";
              break;
            case "AccountName": azureAccount = parsedItem[1]; break;
            case "DefaultEndpointsProtocol": defaultEndpointsProtocol = parsedItem[1]; break;
            case "Endpoint": azureEndpoint = parsedItem[1]; break;
            default: break;
              }
            }

            if (azureEndpoint == string.Empty)
              azureEndpoint = string.Format("{0}://{1}.blob.core.windows.net/", defaultEndpointsProtocol, azureAccount);

            byte[] xmlFragment = null;
            Finsel.AzureCommands.AzureBlobStorage abs = new Finsel.AzureCommands.AzureBlobStorage(azureAccount, azureEndpoint, azureSharedKey, "SharedKey");
            azureResults ar = new azureResults();
            xmlFragment = abs.GetBlob(configBlobContainer, "configuration.xml", "", ref ar);
            System.Text.ASCIIEncoding enc = new System.Text.ASCIIEncoding();
            retVal = enc.GetString(xmlFragment);
            client.Store(Enyim.Caching.Memcached.StoreMode.Set, "config", retVal, new TimeSpan(0, 10, 0));
               // HttpRuntime.Cache.Insert("configuration", retVal,null,  System.Web.Caching.Cache.NoAbsoluteExpiration, new TimeSpan(0, 10, 0));
              }

              return retVal;
        }
        public void ProcessRequest(HttpContext context)
        {
            if (!string.IsNullOrEmpty(context.Request.QueryString["files"]))
              {
            string eTag = string.Empty;
            string cacheKeyETag = string.Format("etag:{0}{1}{2}", context.Request.Url.DnsSafeHost, context.Request.QueryString["files"], context.Request.QueryString["m"]);
            string retVal = string.Empty;
            if (context.Request.Headers["If-None-Match"] != string.Empty && context.Request.Headers["If-None-Match"] != null)
            {
              retVal = client.Get(cacheKeyETag) as string;
            }
            if (retVal == string.Empty || retVal == null)
            {
              FrameworkUtility aau = new FrameworkUtility();
              string[] relativeFiles = context.Request.QueryString["files"].Split(',');
              string[] absoluteFiles = new string[relativeFiles.Length];
              bool minifyData = (context.Request.QueryString["m"] != null);

              // Azure Blob Set up
              //string retVal = string.Empty;
              XmlDocument xdoc = new XmlDocument();
              xdoc.LoadXml(new Utility().getConfigXML());
              string hostName = context.Request.Headers["Host"];
              if (hostName.Contains(":"))
            hostName = hostName.Substring(0, hostName.IndexOf(":"));
              XmlNode xNode = xdoc.SelectSingleNode(string.Format("//blobData[@name='{0}']", hostName));
              if (xNode == null)
            xNode = xdoc.SelectSingleNode(string.Format("//blobData[@name='{0}']", hostName.Substring(hostName.IndexOf(".") + 1)));

              if (xNode == null)
            xNode = xdoc.SelectSingleNode("//blobData[@name='default']");
              string mimeType = string.Empty;
              string azureAccount = xNode.SelectSingleNode("Setting[@name='account']").Attributes["value"].Value;
              string azureEndpoint = xNode.SelectSingleNode("Setting[@name='endpoint']").Attributes["value"].Value;
              string azureSharedKey = xNode.SelectSingleNode("Setting[@name='accountSharedKey']").Attributes["value"].Value;
              string azureRootContainer = string.Empty;
              try { azureRootContainer = xNode.SelectSingleNode("Setting[@name='rootContainer']").Attributes["value"].Value; }
              catch { azureRootContainer = "$root"; }
              string blobStorage = azureEndpoint;
              AzureBlobStorage abs = new AzureBlobStorage(azureAccount, blobStorage, azureSharedKey, "SharedKey");
              azureResults ar = new azureResults();
              context.Response.Headers.Add("P3P", "CP=HONK");
              SetCompression(context);
              StringBuilder sbReturnData = new StringBuilder();
              for (int i = 0; i < relativeFiles.Length; i++)
              {
            string cPath = relativeFiles[i];
            if (mimeType == string.Empty)
            {
              mimeType = GetMimeType(cPath.Substring(cPath.LastIndexOf('.'))); //ar.Headers["Content-Type"].ToString();
            }
            {
              try
              {
                if (!cPath.Contains(".") && !cPath.EndsWith("/"))
                  cPath += "/";
                string containerName = string.Empty;
                string blobName = string.Empty;
                string[] aPath = cPath.Split("/".ToCharArray());
                if (aPath.Count() > 1)
                  containerName = aPath[1];
                if (!cPath.Substring(1).Contains("/"))
                {
                  containerName = azureRootContainer;
                  blobName = cPath.Substring(1).TrimStart();
                }
                else
                {
                  if (cPath.Length > containerName.Length + 2)
                    blobName = cPath.Substring(containerName.Length + 2).TrimStart();
                }
                if (blobName != string.Empty)
                {
                  ar = new azureResults();
                  byte[] xmlFragment = abs.GetBlob(containerName, blobName, "", ref ar, eTag);
                  if (ar.StatusCode == System.Net.HttpStatusCode.NotModified)
                  {
                  }
                  else if (ar.StatusCode != System.Net.HttpStatusCode.OK)
                  {
                    Console.WriteLine("HUH?");
                  }
                  else
                  {
                    context.Response.AppendToLog(string.Format("trying to send {0} {1}", containerName, blobName));
                    System.Text.ASCIIEncoding enc = new System.Text.ASCIIEncoding();
                    eTag = string.Format("{0}{1}", eTag, ar.Headers["ETag"].ToString());
                    if (minifyData)
                    {
                      if (mimeType == "text/css")
                        sbReturnData.Append(new CssCompressor().Compress(enc.GetString(xmlFragment)));
                      else if (cPath.Substring(cPath.LastIndexOf('.')).ToLower() == ".js")
                        sbReturnData.Append(new JavaScriptCompressor().Compress(enc.GetString(xmlFragment)));
                      else sbReturnData.Append(enc.GetString(xmlFragment));
                    }
                    else
                      sbReturnData.Append(enc.GetString(xmlFragment));
                  }
                }

              }
              catch (Exception ex)
              {
                //context.Response.Status =
                context.Response.StatusCode = 404;
                context.Response.Close();
              }
            }
              }
              retVal = sbReturnData.ToString();
              client.Store(Enyim.Caching.Memcached.StoreMode.Set, cacheKeyETag, retVal, new TimeSpan(0, 10, 0));
            }

              context.Response.Write(retVal );

            context.Response.ContentType = context.Request.QueryString["contenttype"];
            //context.Response.AddFileDependencies(files);
            //context.Response.Cache.VaryByParams["stylesheets"] = true;
            //context.Response.Cache.SetETagFromFileDependencies();
            //context.Response.Cache.SetLastModifiedFromFileDependencies();
            context.Response.Cache.SetValidUntilExpires(true);
            context.Response.Headers.Add("ETag", cacheKeyETag);
            context.Response.Cache.SetExpires(DateTime.Now.AddMinutes(10));
            context.Response.Cache.SetCacheability(HttpCacheability.Public);
            //SetHeaders(context, absoluteFiles);
              }
        }
Example #3
0
 public void RetrieveBlobs()
 {
     System.Collections.Hashtable metadata = new System.Collections.Hashtable();
        AzureBlobStorage abs = new AzureBlobStorage(Account, EndPoint, SharedKey, "SharedKey");
        if (Container == "*")
        {
     azureResults ar = abs.GetContainerList("");
     XmlDocument xdoc = new XmlDocument();
     xdoc.LoadXml(ar.Body);
     XmlNodeList xnl = xdoc.SelectNodes("//Name");
     foreach (XmlNode xn in xnl)
     {
      ProcessContainer(abs, metadata, StartingDirectory,  xn.InnerText);
     }
        }
        else
        {
     azureResults ar = abs.Containers(cmdType.get, Container, new System.Collections.Hashtable());
     if (!ar.Succeeded)
      ar = abs.Containers(cmdType.post, Container, metadata);
     ProcessContainer(abs, metadata, StartingDirectory, Container);
        }
 }
Example #4
0
        private void txtProcessDemo_Click(object sender, EventArgs e)
        {
            this.Cursor = Cursors.WaitCursor;

               StringBuilder sbResultsForStorage = new StringBuilder();
               AzureQueueStorage aqs = new AzureQueueStorage(txtAccount.Text, string.Format("http://{0}.queue.core.windows.net", txtAccount.Text), txtSharedKey.Text, "SharedKey");
               azureResults ar = aqs.Messages(cmdType.get, bulkTag, "", "visibilitytimeout=7200", "");
               string MessageID = "";
               string PopReceipt = "";
               string Message = "";
               if (ar.Body != null)
               {
            System.Xml.XmlDocument xdoc = new System.Xml.XmlDocument();
            if (ar.Succeeded)
            {
             xdoc.LoadXml(ar.Body);
             System.Xml.XmlNodeList nodes = xdoc.SelectNodes("//QueueMessage");
             StringBuilder sbMultipart = new StringBuilder();
             if (nodes.Count == 0)
              txtMessage.Text = "No message to process";
             else
              foreach (System.Xml.XmlNode node in nodes)
              {
               MessageID = node.SelectSingleNode("MessageId").InnerText;
               PopReceipt = node.SelectSingleNode("PopReceipt").InnerText;
               Message = node.SelectSingleNode("MessageText").InnerText;

               System.Xml.XmlDocument msgDoc = new XmlDocument();
               msgDoc.LoadXml(Message);
               string newAccount = msgDoc.SelectSingleNode("//account[1]").InnerXml;
               string newKey = msgDoc.SelectSingleNode("//key[1]").InnerXml;
               string newSource = msgDoc.SelectSingleNode("//source[1]").InnerXml;
               string updateID = msgDoc.SelectSingleNode("//updateID[1]").InnerXml;
               string newTable = msgDoc.SelectSingleNode("//table[1]").InnerXml;
               AzureTableStorage ats = new AzureTableStorage(txtAccount.Text, "", txtSharedKey.Text, "SharedKey");
               AzureTableStorage ats1 = new AzureTableStorage(txtAccount.Text, "", txtSharedKey.Text, "SharedKey");

               azureHelper ah = new azureHelper(txtAccount.Text, txtEndpoint.Text, txtSharedKey.Text, "SharedKey");

               string mrgMessage = string.Format(queueUpdateCreationEntity, updateID, 0, 0);
               ats.Entities(cmdType.merge, bulkTag, updateID, "000000000000000", mrgMessage, "");
               ats.Entities(cmdType.merge, bulkTag, updateID, "000000000000000", string.Format("<m:properties>\n\t<d:PartitionKey>{0}</d:PartitionKey>\n\t<d:RowKey>000000000000000</d:RowKey><d:StartedProcessing>{1}</d:StartedProcessing></m:properties>", updateID, DateTime.UtcNow.ToLongTimeString()), "");

               AzureBlobStorage abs = new AzureBlobStorage(newAccount, string.Format("http://{0}.blob.core.windows.net", newAccount), newKey, "SharedKey");

               AzureTableStorage atsNew = new AzureTableStorage(newAccount, string.Format("http://{0}.blob.core.windows.net", newAccount), newKey, "SharedKey");
               ar = atsNew.Tables(cmdType.post, newTable);
               if (ar.Succeeded || ar.StatusCode == System.Net.HttpStatusCode.Conflict)
               {
            ar = new azureResults();
            string newContainer = newSource.Replace(string.Format("http://{0}.blob.core.windows.net/", newAccount), "");
            newContainer = newContainer.Substring(0, newContainer.IndexOf("/"));
            string newBlob = newSource.Replace(string.Format("http://{0}.blob.core.windows.net/", newAccount), "").Replace(newContainer, "");
            byte[] blob = abs.GetBlob(newContainer, newBlob, "", ref ar);
            string x = new System.Text.UTF8Encoding().GetString(blob);
            x = x.Substring(x.IndexOf("<"));
            msgDoc.LoadXml(x);

            int errorCt = 0;
            int processedCt = 0;
            //Instantiate an XmlNamespaceManager object.
            System.Xml.XmlNamespaceManager xmlnsManager = new System.Xml.XmlNamespaceManager(xdoc.NameTable);

            //Add the namespaces used in books.xml to the XmlNamespaceManager.
            xmlnsManager.AddNamespace("d", "http://schemas.microsoft.com/ado/2007/08/dataservices");
            xmlnsManager.AddNamespace("m", "http://schemas.microsoft.com/ado/2007/08/dataservices/metadata");
            XmlNodeList pnodes = msgDoc.SelectNodes("//m:properties", xmlnsManager);
            int iCounter = 101;
            int iResponse = 1;
            foreach (XmlNode pnode in pnodes)
            {
             if (iCounter > 100)
             {
              if (sbMultipart.Length > 0)
              {
               sbMultipart.Append("</entry>");
               ProcessMultiPartForStatus(ats.auth, ah.entityGroupTransaction(cmdType.post, newTable, sbMultipart.ToString()), bulkTag, updateID, iResponse.ToString("D15"), ref processedCt, ref errorCt, "201 Created");
               ar = ats1.Entities(cmdType.post, bulkTag, updateID, iResponse.ToString("D15"), sbResultsForStorage.ToString(), "");
               mrgMessage = string.Format(queueUpdateCreationEntity, updateID, processedCt, errorCt);
               ats.Entities(cmdType.merge, bulkTag, updateID, "000000000000000", mrgMessage, "", "*");
               iResponse++;
              }
              sbMultipart = new StringBuilder();
              sbMultipart.AppendFormat(@"<?xml version=""1.0"" encoding=""utf-8"" ?><entry xml:base=""http://finseldemos.table.core.windows.net/"" xmlns:d=""http://schemas.microsoft.com/ado/2007/08/dataservices"" xmlns:m=""http://schemas.microsoft.com/ado/2007/08/dataservices/metadata"" xmlns=""http://www.w3.org/2005/Atom"">");
              iCounter = 0;
             }
             sbMultipart.Append(pnode.OuterXml);
             iCounter++;

            }
            sbMultipart.Append("</entry>");
            ProcessMultiPartForStatus(ats.auth, ah.entityGroupTransaction(cmdType.post, newTable, sbMultipart.ToString()), bulkTag, updateID, iResponse.ToString("D15"), ref processedCt, ref errorCt, "201 Created");
            mrgMessage = string.Format(queueUpdateCreationEntity, updateID, processedCt, errorCt).Replace("Processing", "Completed");
            ats.Entities(cmdType.merge, bulkTag, updateID, "000000000000000", mrgMessage, "", "*");

               }
               else
               {
            mrgMessage = string.Format(queueUpdateCreationEntity, updateID, 0, 0).Replace("Processing", "Failed to create table!");
            ats.Entities(cmdType.merge, bulkTag, updateID, "000000000000000", mrgMessage, "");
               }
               aqs.Messages(cmdType.delete, bulkTag, "", string.Format("popreceipt={0}", PopReceipt), MessageID);
               ats.Entities(cmdType.merge, bulkTag, updateID, "000000000000000", string.Format("<m:properties>\n\t<d:PartitionKey>{0}</d:PartitionKey>\n\t<d:RowKey>000000000000000</d:RowKey><d:CompletedProcessing>{1}</d:CompletedProcessing></m:properties>", updateID, DateTime.UtcNow.ToLongTimeString()), "");
              }

            }
            else txtMessage.Text = "No message to process";
            ProcessResults(ar);
            this.Cursor = Cursors.Default;
               }
        }
Example #5
0
 private void button1_Click(object sender, EventArgs e)
 {
     this.Cursor = Cursors.WaitCursor;
        AzureBlobStorage abs = new AzureBlobStorage(txtAccount.Text, string.Format("http://{0}.blob.core.windows.net", txtAccount.Text), txtSharedKey.Text, "SharedKey");
        azureResults ar = abs.MetaData(cmdType.put , cbBlobContainers.Text,cbBlobs.Text , null);
        ProcessResults(ar);
        this.Cursor = Cursors.Default;
 }
Example #6
0
        private void btnTestBlocks_Click(object sender, EventArgs e)
        {
            Hashtable ht = new Hashtable();
               string[] AllData = txtMetaData.Text.Split("\n".ToCharArray());
               foreach (string metadataDetail in AllData)
               {
            //string[] detail = metadataDetail.Split(":".ToCharArray());
            string metadataName = string.Empty;
            string metadataValue = string.Empty;
            if (metadataDetail.Contains(":"))
            {
             metadataName = metadataDetail.Substring(0, metadataDetail.IndexOf(":"));
             if (!metadataName.StartsWith("x-ms-meta-"))
              metadataName = "x-ms-meta-" + metadataName;
             if (metadataDetail.Length > metadataDetail.IndexOf(":"))
              metadataValue = metadataDetail.Substring(metadataDetail.IndexOf(":") + 1);
            }
            else
             metadataName = metadataDetail;

            if (metadataName != string.Empty)
            {

             metadataValue = metadataValue.Replace("\r", "");
             if (ht.ContainsKey(metadataName))
              ht[metadataName] = string.Format("{0},{1}", ht[metadataName].ToString(), metadataValue);
             else
              ht.Add(metadataName, metadataValue);
            }
               }

               AzureBlobStorage  abs= new AzureBlobStorage (txtAccount.Text, txtEndpoint.Text, txtSharedKey.Text, "SharedKey");
               string OriginalUrl = string.Format("http://{0}.blob.core.windows.net/{1}/{2}", txtAccount.Text, cbBlobContainers.Text, cbBlobs.Text);
               if (txtBlobLocation.Text.StartsWith("/"))
            txtBlobLocation.Text = txtBlobLocation.Text.Substring(1);
               string newURL = string.Format("http://{0}.blob.core.windows.net/{1}", txtAccount.Text,txtBlobLocation.Text );
               azureResults ar = abs.CopyBlob(OriginalUrl, newURL, ht);
               ar.Succeeded = (ar.StatusCode == System.Net.HttpStatusCode.Created);
        }
Example #7
0
        private void btnPutBlobs_Click(object sender, EventArgs e)
        {
            this.Cursor = Cursors.WaitCursor;
               string filename = txtBlobLocation.Text;
               if (!File.Exists(filename))
            MessageBox.Show(string.Format("{0} is not a valid file", filename), "Error with file", MessageBoxButtons.OK, MessageBoxIcon.Error);
               else
               {
             if (cbBlobs.Text == string.Empty)
               //     MessageBox.Show("You must specify a blob name!", "Blob name missing", MessageBoxButtons.OK, MessageBoxIcon.Error);
               cbBlobs.Text = new FileInfo(filename).Name;
             //else
             {
               byte[] blobArray = FileToByteArray(filename);

               AzureBlobStorage abs = new AzureBlobStorage(txtAccount.Text, string.Format("http://{0}.blob.core.windows.net", txtAccount.Text), txtSharedKey.Text, "SharedKey");
               azureResults ar = abs.PutBlob(blobArray.Length, getMimeType(filename), blobArray, cbBlobContainers.Text, cbBlobs.Text, new Hashtable(), (chkPageBlob.Checked ? AzureBlobStorage.BlobType.PageBlob : AzureBlobStorage.BlobType.BlockBlob));
               ProcessResults(ar);
             }
               }
               this.Cursor = Cursors.Default;
        }
Example #8
0
 private void btnHeadBlob_Click(object sender, EventArgs e)
 {
     this.Cursor = Cursors.WaitCursor;
       AzureBlobStorage abs = new AzureBlobStorage(txtAccount.Text, string.Format("http://{0}.blob.core.windows.net", txtAccount.Text), txtSharedKey.Text, "SharedKey");
       azureResults ar = new azureResults();
       ar= abs.Blobs(cmdType.head,cbBlobContainers.Text, cbBlobs.Text, new Hashtable(), "");
       ProcessResults(ar);
       this.Cursor = Cursors.Default;
 }
 private void mnuLeaseBlob_Click(object sender, RoutedEventArgs e)
 {
     this.Cursor = Cursors.Wait;
     TreeViewItem tvI = (TreeViewItem)tvBlobs.SelectedItem;
     string containerName = tvI.Parent.ToString();
     string blobName = tvI.ToString();
     AzureBlobStorage abs = new AzureBlobStorage(azAccount, string.Format("http://{0}.blob.core.windows.net", azAccount), azSharedKey, "SharedKey");
     AzureBlobStorage.BlobLease bl = AzureBlobStorage.BlobLease.acquireLease;
     bl = AzureBlobStorage.BlobLease.acquireLease;
     if (e.Source == mnuAcquireLease)
         bl = AzureBlobStorage.BlobLease.acquireLease;
     if(e.Source ==mnuBreakLease)
         bl = AzureBlobStorage.BlobLease.breakLease;
     if(e.Source==mnuReleaseLease)
         bl = AzureBlobStorage.BlobLease.releaseLease;
     if(e.Source==mnuRenewLease)
         bl = AzureBlobStorage.BlobLease.renewLease;
     azureResults ar = abs.LeaseBlob(containerName, blobName , bl, txtLeaseID.Text);
     ProcessResults(ar);
     //x-ms-lease-id: 0488ee2d-7268-40fb-adc9-400549f1d86a
     if (ar.Headers != null)
     {
         if (ar.Headers.ContainsKey("x-ms-lease-id"))
             txtLeaseID.Text = ar.Headers["x-ms-lease-id"].ToString();
         else txtLeaseID.Text = string.Empty;
     }
     this.Cursor = Cursors.Arrow;
 }
 private void mnuDeleteContainer_Click(object sender, RoutedEventArgs e)
 {
     if (tvBlobs.SelectedItem != null)
     {
         TreeViewItem item = (TreeViewItem)tvBlobs.SelectedItem;
         if (item.Tag is blobContainer)
         {
             DeleteContainer dc = new DeleteContainer();
             dc.txtNewContainerName.Text = ((blobContainer)item.Tag).ContainerName;
             dc.ShowDialog();
             if (!dc.cancelled)
             {
                 this.Cursor = Cursors.Wait;
                 AzureBlobStorage abs = new AzureBlobStorage(azAccount, string.Format("http://{0}.blob.core.windows.net",
                     azAccount), azSharedKey, "SharedKey");
                 azureResults ar = abs.Containers(cmdType.delete, dc.txtNewContainerName.Text, new Hashtable());
                 ProcessResults(ar);
                 if (ar.Succeeded)
                 {
                     tvBlobs.Items.Remove(item);
                 }
                 this.Cursor = Cursors.Arrow;
             }
         }
         else if (item.Tag is blobPrefix)
         { }
         else if (item.Tag is blobData)
         { }
     }
 }
        private void mnuDeleteBlob_Click(object sender, RoutedEventArgs e)
        {
            TreeViewItem item = (TreeViewItem)tvBlobs.SelectedItem;
            if (item.Tag is blobData)
            {

                if (MessageBox.Show(string.Format("Delete {0}/{1}?",((blobData)item.Tag).ContainerName, ((blobData)item.Tag).BlobName), "Confirmation", MessageBoxButton.YesNoCancel) == MessageBoxResult.Yes)
                {
                    this.Cursor = Cursors.Wait;
                    string ContainerName = ((blobData)item.Tag).ContainerName;
                    string BlobName = ((blobData)item.Tag).BlobName;
                    AzureBlobStorage abs = new AzureBlobStorage(azAccount, string.Format("http://{0}.blob.core.windows.net", azAccount), azSharedKey, "SharedKey");
                    azureResults ar = abs.DeleteBlob(ContainerName, BlobName);
                    ProcessResults(ar);
                    if (ar.Succeeded)
                    {
                        tvBlobs.Items.Remove(item);
                    }
                    this.Cursor = Cursors.Arrow;
                }
            }
        }
        private void LoadContainers()
        {
            this.Cursor = Cursors.Wait;
            tvBlobs.Items.Clear();

            AzureBlobStorage abs = new AzureBlobStorage(azAccount, string.Format("http://{0}.blob.core.windows.net", azAccount), azSharedKey, "SharedKey");
            azureResults ar = abs.GetContainerList("");
            if (ar.Succeeded)
            {
                XmlDocument xdoc = new XmlDocument();
                xdoc.LoadXml(ar.Body);
                XmlNodeList nodes = xdoc.SelectNodes("//Container");

                foreach (XmlNode node in nodes)
                {
                    TreeViewItem tvI = new TreeViewItem();
                    blobContainer bc = new blobContainer();
                    try{bc.ContainerName = node.SelectSingleNode("Name").InnerText;}
                    catch { }
                    try {bc.Etag = node.SelectSingleNode("Properties/Etag").InnerText;}
                    catch { }
                    try {bc.LeaseState = node.SelectSingleNode("Properties/LeaseState").InnerText;}
                    catch { }
                    try {bc.LeaseStatus = node.SelectSingleNode("Properties/LeaseStatus").InnerText;}
                    catch { }
                    try { bc.LastModified = node.SelectSingleNode("Properties/LastModified").InnerText; }
                    catch { }
                    tvI.Header = bc.ContainerName;
                    tvI.Tag = bc;
                    tvI.Items.Add("*");
                    tvBlobs.Items.Add(tvI);
                }
                mnuNewBlobContainer.IsEnabled = true;
                mnuDeleteContainer.IsEnabled = true;
            }
            ProcessResults(ar);
            this.Cursor = Cursors.Arrow;
        }
 private void GetBlobData(string containerName, string blobName)
 {
     this.Cursor = Cursors.Wait;
     resetBlobContainerText();
     containerDataPanel.Visibility = System.Windows.Visibility.Collapsed;
     blobDataPanel.Visibility = System.Windows.Visibility.Visible;
     AzureBlobStorage abs = new AzureBlobStorage(azAccount, string.Format("http://{0}.blob.core.windows.net", azAccount), azSharedKey, "SharedKey");
     azureResults ar = abs.Blobs(cmdType.head, containerName, blobName, new Hashtable(), "");
     ProcessResults(ar);
     // load detail pane
     StringBuilder sbMeta = new StringBuilder();
     txtBlobContainerUrl.Text = ar.Url;
     foreach (DictionaryEntry item in ar.Headers)
     {
         if (item.Key.ToString().StartsWith("x-ms-meta")) // need to populate metadata
         {
             sbMeta.AppendLine(string.Format("{0}:{1}", item.Key.ToString(), item.Value.ToString()));
         }
         switch (item.Key.ToString())
         {
             case "Content-Encoding": txtContentEncoding.Text = item.Value.ToString(); break;
             case "Content-Length": txtBlobSize.Text = item.Value.ToString(); break;
             case "Content-MD5": txtBlobMD5.Text = item.Value.ToString(); break;
             case "Content-Type": txtContentType.Text = item.Value.ToString(); break;
             case "ETag": txtETag.Text = item.Value.ToString(); break;
             case "Last-Modified": txtLastModified.Text = item.Value.ToString(); break;
             case "x-ms-blob-type": txtBlobType.Text = item.Value.ToString(); break;
             case "x-ms-lease-duration": txtLeaseDuration.Text = item.Value.ToString(); break;
             case "x-ms-lease-state": txtLeaseState.Text = item.Value.ToString(); break;
             case "x-ms-lease-status": txtLeaseStatus.Text = item.Value.ToString(); break;
             case "x-ms-version": txtblobContainerVersion.Text = item.Value.ToString(); break;
         }
     }
     txtBlobContainerHeaders.Text = sbMeta.ToString();
 }
        private void ExpandBlobItem(TreeViewItem item)
        {
            this.Cursor = Cursors.Wait;

            item.Items.Clear();
            AzureBlobStorage abs = new AzureBlobStorage(azAccount, string.Format("http://{0}.blob.core.windows.net", azAccount), azSharedKey, "SharedKey");
            string parameterList = string.Empty;

            parameterList = "delimiter=/";
            /* if (chkIncludeSnapshots.Checked)
             {
                 if (parameterList != string.Empty)
                     parameterList = string.Format("{0}&include=snapshots", parameterList);
                 else parameterList = "include=snapshots";
             }
             if (chkUncommittedBlobs.Checked)
             {
                 if (parameterList != string.Empty)
                     parameterList = string.Format("{0}&include=uncommittedblobs", parameterList);
                 else parameterList = "include=uncommittedblobs";
             }
             */
            string path = string.Empty;
            if (item.Tag is blobPrefix)
            {
                blobPrefix bp = (blobPrefix)item.Tag;
                path = bp.ContainerName;
                parameterList = string.Format("delimiter=/&prefix={0}", bp.fullPath);
            }
            if (item.Tag is blobContainer)
            {
                path = ((blobContainer)item.Tag).ContainerName;
            }
            azureResults ar = abs.GetBlobList(path, parameterList);
            if (ar.Succeeded)
            {
                XmlDocument xdoc = new XmlDocument();
                xdoc.LoadXml(ar.Body);
                XmlNodeList nodes = xdoc.SelectNodes("//BlobPrefix");
                foreach (XmlNode node in nodes)
                {
                    TreeViewItem tvIAdd = new TreeViewItem();
                    string headerInfo = node.SelectSingleNode("Name").InnerText;
                    if (item.Tag is blobPrefix)
                        headerInfo = headerInfo.Replace(((blobPrefix)item.Tag).fullPath, "");
                    tvIAdd.Header = headerInfo.Replace("/", "");
                    blobPrefix bp = new blobPrefix();
                    if (item.Tag is blobContainer)
                    {
                        bp.ContainerName = ((blobContainer)item.Tag).ContainerName;
                        bp.fullPath = node.SelectSingleNode("Name").InnerText;
                    }
                    if (item.Tag is blobPrefix)
                    {
                        bp.ContainerName = ((blobPrefix)item.Tag).ContainerName;
                        bp.fullPath = node.SelectSingleNode("Name").InnerText;
                    }
                    tvIAdd.Tag = bp;
                    tvIAdd.Items.Add("*");
                    item.Items.Add(tvIAdd);
                }

                nodes = xdoc.SelectNodes("//Blob");

                foreach (XmlNode node in nodes)
                {
                    TreeViewItem tvIAdd = new TreeViewItem();
                    blobData bd = new blobData();
                    bd.Url = node.SelectSingleNode("Url").InnerText;
                    bd.BlobName = bd.Url.Substring(bd.Url.IndexOf(".net") + 5);
                    bd.ContainerName = bd.BlobName.Substring(0, bd.BlobName.IndexOf("/"));
                    bd.BlobName = bd.BlobName.Substring(bd.BlobName.IndexOf("/")+1);
                    bd.LastModified = node.SelectSingleNode(@"Properties/Last-Modified").InnerText;
                    bd.Etag = node.SelectSingleNode(@"Properties/Etag").InnerText;
                    bd.ContentLength = Convert.ToInt64(node.SelectSingleNode(@"Properties/Content-Length").InnerText);
                    bd.ContentType = node.SelectSingleNode(@"Properties/Content-Type").InnerText;
                    bd.BlobType = node.SelectSingleNode(@"Properties/BlobType").InnerText;
                    bd.LeaseStatus = node.SelectSingleNode(@"Properties/LeaseStatus").InnerText;
                    tvIAdd.Tag = bd;
                    string headerInfo = node.SelectSingleNode("Name").InnerText;
                    if (item.Tag is blobPrefix)
                        headerInfo = headerInfo.Replace(((blobPrefix)item.Tag).fullPath, "");
                    if (node.SelectSingleNode("Snapshot") == null)
                        tvIAdd.Header = headerInfo;
                    else
                        tvIAdd.Header = string.Format("{0}?snapshot={1}", headerInfo, node.SelectSingleNode("Snapshot").InnerText);
                    //if (bd.ContentLength == 0) tvIAdd.Items.Add("*");

                    item.Items.Add(tvIAdd);
                }
            }
            ProcessResults(ar);
            this.Cursor = Cursors.Arrow;
        }
        public void ProcessRequest(HttpContext context)
        {
            Int64 expirationSeconds = 1;
              HttpCacheability hc = HttpCacheability.NoCache;

              try
              {
            string retVal = string.Empty;
            XmlDocument xdoc = new XmlDocument();
            xdoc.LoadXml(new Utility().getConfigXML());
            XmlNode xNode = xdoc.SelectSingleNode("//blobData[@name='default']");

            string azureAccount = xNode.SelectSingleNode("Setting[@name='account']").Attributes["value"].Value;
            string azureEndpoint = xNode.SelectSingleNode("Setting[@name='endpoint']").Attributes["value"].Value;
            string azureSharedKey = xNode.SelectSingleNode("Setting[@name='accountSharedKey']").Attributes["value"].Value;
            string blobStorage = azureEndpoint;

            xNode = xdoc.SelectSingleNode(string.Format("//fragmentData/Setting[@name='luceneFragments']"));
            string fragmentLocation = xNode.Attributes["value"].Value ;

            string queryName = string.Empty;

            SetCompression(context);

            try
            {
              AzureBlobStorage abs = new AzureBlobStorage(azureAccount, blobStorage, azureSharedKey, "SharedKey");
              azureResults ar = new azureResults();
              // Get the page name and replace the .q extension with .xml
              queryName = context.Request.Path;
              queryName = queryName.Substring(queryName.LastIndexOf("/") + 1);
              queryName = queryName.Substring(0, queryName.LastIndexOf(".")) + ".xml";
              byte[] xmlFragment = abs.GetBlob(fragmentLocation, queryName, "", ref ar, "");
              if (!ar.Succeeded)
              {
            context.Response.StatusCode = (int)ar.StatusCode;
              }
              else
              {
            xdoc = new XmlDocument();
            System.Text.ASCIIEncoding enc = new System.Text.ASCIIEncoding();
            xdoc.LoadXml(enc.GetString(xmlFragment));
            /*
             * http://azure-architect.com/portals/16/MOOPData.xsd

             */
            string azureContainerName = string.Empty;
            azureContainerName = xdoc.SelectSingleNode("//MOOPData/luceneSearch/azureContainer[1]").InnerText;
            Microsoft.WindowsAzure.StorageCredentialsAccountAndKey scaak = new Microsoft.WindowsAzure.StorageCredentialsAccountAndKey(azureAccount, azureSharedKey);
            Microsoft.WindowsAzure.CloudStorageAccount csa = new Microsoft.WindowsAzure.CloudStorageAccount(scaak, false);
            AzureDirectory azDir = new AzureDirectory(csa, azureContainerName, new RAMDirectory());

            //            IndexSearcher searcher = new IndexSearcher("azure-lucene-search");
            try
            {
              var q = new BooleanQuery();
              XmlNode xn = xdoc.SelectSingleNode("//luceneSearch[1]");
              XmlNodeList xnl = xn.SelectNodes("//query");
              Query[] qArray = new Query[xnl.Count];
              bool hasReplaceableSearchValues = false;
              bool hasReplacedAtLeastOneValue = false;
              bool requirementsMet = true;
              for (int i = 0; i < xnl.Count; i++)
              {
                XmlNode node = xnl[i];
                string term = string.Empty;
                term = node.Attributes["term"].Value;
                string termValue = node.Attributes["termValue"].Value;
                string variableValue = node.Attributes["variableValue"].Value;
                string parmValue = string.Empty;
                string requiredField = node.Attributes["required"].Value;
                if (variableValue == "true") // See if there is a replacement attempt
                {
                  if (requiredField == "true" && !context.Request.Params.AllKeys.Contains(termValue))
                    requirementsMet = false;
                  hasReplaceableSearchValues = true; // Set the flag to say we are attempting to replace the value
                  if (context.Request.Params.AllKeys.Contains(termValue)) // The parameter exists
                  {
                    hasReplacedAtLeastOneValue = true;
                    parmValue = context.Request.Params[termValue].Replace("+", " ").Replace("%20", " ");
                  }
                }
                if (node.Attributes["useAnalyzer"].Value == "true") // Should we use the analyzer
                {

                  if (variableValue == "true" && context.Request.Params.AllKeys.Contains(termValue)) // Did we actually have a replaceable value or a static value
                    qArray[i] = new QueryParser(Lucene.Net.Util.Version.LUCENE_29, term, new SnowballAnalyzer("English")).Parse(parmValue);
                   if (variableValue != "true")
                    qArray[i] = new QueryParser(Lucene.Net.Util.Version.LUCENE_29, term, new SnowballAnalyzer("English")).Parse(termValue);
                }
                else // Using a Boolean
                {
                  if (variableValue == "true" && context.Request.Params.AllKeys.Contains(termValue)) // Did we actually have a replaceable value or a static value
                    qArray[i] = new TermQuery(new Term(term, parmValue));
                  if (variableValue != "true")
                    qArray[i] = new TermQuery(new Term(term, termValue));
                }
                if (qArray[i] != null)
                {
                  switch (node.Attributes["booleanClauseOccurs"].Value.ToLower())
                  {
                    case "must": q.Add(new BooleanClause(qArray[i], BooleanClause.Occur.MUST)); break;
                    case "must_not": q.Add(new BooleanClause(qArray[i], BooleanClause.Occur.MUST_NOT)); break;
                    case "should": q.Add(new BooleanClause(qArray[i], BooleanClause.Occur.SHOULD)); break;
                    default: q.Add(new BooleanClause(qArray[i], BooleanClause.Occur.MUST)); break;
                  }
                }
              }
              IndexSearcher searcher2 = new IndexSearcher(azDir, true);
              TopScoreDocCollector collector = TopScoreDocCollector.Create(1000, true);
              // If we have either no replaceable values or have replaceable values and at least one was provided
              if (!hasReplaceableSearchValues || (hasReplaceableSearchValues && hasReplacedAtLeastOneValue))
                if (requirementsMet)
                  searcher2.Search(q, collector);
              int indexID = 1;
              ScoreDoc[] hits = collector.TopDocs().ScoreDocs;
              StringBuilder xmlOutput = new StringBuilder();
              xmlOutput.AppendFormat("<?xml version=\"1.0\"?><root>");
              for (int i = 0; i < hits.Length; ++i)
              {
                xmlOutput.AppendFormat("<hit>");
                int docId = hits[i].Doc;
                Document d = searcher2.Doc(docId);
                xmlOutput.AppendFormat("<score>{0}</score><docID>{1}</docID>", hits[i].Score, indexID ++);
                foreach (Field f in d.GetFields())
                {
                  if (f.StringValue() == null)
                    xmlOutput.AppendFormat("<{0} />", f.Name());
                  else
                    xmlOutput.AppendFormat("<{0}>{1}</{0}>", f.Name(), System.Security.SecurityElement.Escape(f.StringValue()));
                }
                xmlOutput.AppendFormat("</hit>");
              }
              xmlOutput.AppendFormat("</root>");
              retVal = xmlOutput.ToString();

            }
            catch (Exception ex)
            {
              retVal = "<root />";
            }
            MessageFormatOptions defaultOptions = new MessageFormatOptions();
            string preferredContentType = string.Empty;
            if (context.Request.HttpMethod == "GET" || context.Request.HttpMethod == "DELETE")
            {
                preferredContentType = (context.Request.AcceptTypes ?? new string[0])
                          .Select(m => m.Split(';')[0])
                          .FirstOrDefault(m => defaultOptions.MimeInputTypes.ContainsKey(m))
                          ?? defaultOptions.DefaultContentType;
                if (preferredContentType.Trim() == string.Empty)
                    preferredContentType = context.Request.Headers["Content-Type"];
            }
            else preferredContentType = context.Request.Headers["Content-Type"];
            if (preferredContentType == "application/json")
            {
                context.Response.ContentType = preferredContentType;
                XmlDocument doc = new XmlDocument();
                doc.LoadXml(retVal);
                retVal = JsonConvert.SerializeXmlNode(doc);
            }
            else
            {
                string luceneTransform = string.Empty;
                luceneTransform = xdoc.SelectSingleNode("/MOOPData/luceneSearch/transform").InnerText;
                if (luceneTransform != string.Empty && luceneTransform != null)
                {
                    xmlFragment = abs.GetBlob(fragmentLocation, luceneTransform, "", ref ar, "");
                    if (ar.Succeeded)
                    {
                       XsltUtil xslu = new XsltUtil();
                        retVal = XsltUtil.TransformXml(retVal, System.Text.ASCIIEncoding.ASCII.GetString(xmlFragment));
                        string transformContentType = "text/html";
                        try { transformContentType = xdoc.SelectSingleNode("/MOOPData/luceneSearch/transform").Attributes["contentType"].Value; }
                        catch { }
                        context.Response.ContentType = transformContentType;
                    }
                }

                else
                {
                    context.Response.ContentType = "text/xml";
                }
            }
              }
            }
            catch (Exception ex)
            {
              FrameworkUtility u = new FrameworkUtility(new Utility().ResolveDataConnection("sqlAzureConnection"));
              FrameworkUtility.ParsedURI pUri = new FrameworkUtility.ParsedURI(context.Request.RawUrl);
              u.LogData(pUri.domainName, pUri.folderName, pUri.pageName, context.Request.HttpMethod, context.Request.UserHostAddress, "", "QueryError", ex.ToString(),
            u.nvc2XML(context.Request.Headers));
              //retVal = string.Format("<!-- {0} -->", ex.ToString());
              context.Response.StatusDescription = "An error occured but it was logged for later review";
              context.Response.StatusCode = 400;
            }
            finally { if (retVal == string.Empty) retVal = "<root />"; }

            context.Response.Cache.SetExpires(DateTime.Now.AddSeconds(expirationSeconds));
            context.Response.Cache.SetCacheability(hc);
            context.Response.Write(retVal);
              }
              catch (Exception ex)
              {
            context.Response.StatusCode = 404;
            context.Response.Close();
              }
        }
Example #16
0
 private void btnGetBlob_Click(object sender, EventArgs e)
 {
     this.Cursor = Cursors.WaitCursor;
        AzureBlobStorage abs = new AzureBlobStorage(txtAccount.Text, string.Format("http://{0}.blob.core.windows.net", txtAccount.Text), txtSharedKey.Text, "SharedKey");
        azureResults ar = new azureResults();
        byte[] blob = abs.GetBlob(cbBlobContainers.Text, cbBlobs.Text, "", ref ar);
        if (blob != null)
        {
     string fileName = txtBlobLocation.Text;
     if (File.Exists(fileName))
      fileName = string.Format("{0}{1}", fileName, Guid.NewGuid().ToString());
      if(fileName != string.Empty)
       File.WriteAllBytes(fileName, blob);
        }
        ProcessResults(ar);
        this.Cursor = Cursors.Default;
 }
Example #17
0
        private void btnGetContainers_Click(object sender, EventArgs e)
        {
            this.Cursor = Cursors.WaitCursor;
               cbBlobContainers.Items.Clear();
               cbBlobContainers.Text = string.Empty;

               AzureBlobStorage abs = new AzureBlobStorage(txtAccount.Text, string.Format("http://{0}.blob.core.windows.net", txtAccount.Text), txtSharedKey.Text, "SharedKey");
               azureResults ar = abs.GetContainerList("");
               if (ar.Succeeded)
               {
            XmlDocument xdoc = new XmlDocument();
            xdoc.LoadXml(ar.Body);
            XmlNodeList nodes = xdoc.SelectNodes("//Container");

            foreach (XmlNode node in nodes)
            {
             cbBlobContainers.Items.Add(node.SelectSingleNode("Name").InnerText);
            }
               }
               ProcessResults(ar);
               this.Cursor = Cursors.Default;
        }
 private void mnuNewBlobContainer_Click(object sender, RoutedEventArgs e)
 {
     newContainer nc = new newContainer();
     nc.ShowDialog();
     if (!nc.cancelled)
     {
         this.Cursor = Cursors.Wait;
         AzureBlobStorage abs = new AzureBlobStorage(azAccount, string.Format("http://{0}.blob.core.windows.net", azAccount), azSharedKey, "SharedKey");
         Hashtable htMetaData = new Hashtable();
         htMetaData.Add("x-ms-meta-createdBy", "Finsel.AzureCommands");
         azureResults ar = abs.Containers(cmdType.put, nc.newContainerName, htMetaData);
         ProcessResults(ar);
         if (ar.Succeeded)
         {
             TreeViewItem tvI = new TreeViewItem();
             blobContainer bc = new blobContainer();
             bc.ContainerName = nc.newContainerName;
             tvI.Header = bc.ContainerName;
             tvI.Tag = bc;
             tvI.Items.Add("*");
             tvBlobs.Items.Add(tvI);
         }
         this.Cursor = Cursors.Arrow;
     }
 }
Example #19
0
        private void btnLeaseBlob_Click(object sender, EventArgs e)
        {
            this.Cursor = Cursors.WaitCursor;
            AzureBlobStorage abs = new AzureBlobStorage(txtAccount.Text, string.Format("http://{0}.blob.core.windows.net", txtAccount.Text), txtSharedKey.Text, "SharedKey");
            AzureBlobStorage.BlobLease bl = AzureBlobStorage.BlobLease.acquireLease;
            if (cbLeaseType.SelectedIndex == -1)
              cbLeaseType.SelectedItem = "acquire";
            switch (cbLeaseType.SelectedItem.ToString())
            {
              case "acquire": bl = AzureBlobStorage.BlobLease.acquireLease; break;
              case "break": bl = AzureBlobStorage.BlobLease.breakLease; break;
              case "renew": bl = AzureBlobStorage.BlobLease.renewLease; break;
              case "release": bl = AzureBlobStorage.BlobLease.releaseLease; break;
            }

            azureResults ar = abs.LeaseBlob(cbBlobContainers.Text, cbBlobs.Text, bl, txtLeaseID.Text );
            ProcessResults(ar);
            //x-ms-lease-id: 0488ee2d-7268-40fb-adc9-400549f1d86a
            if (ar.Headers != null)
            {
              if (ar.Headers.ContainsKey("x-ms-lease-id"))
            txtLeaseID.Text = ar.Headers["x-ms-lease-id"].ToString();
              else txtLeaseID.Text = string.Empty;
            }
            this.Cursor = Cursors.Default;
        }
        public void ProcessRequest(HttpContext context)
        {
            string accountName = string.Empty;
              string sharedKey = string.Empty;
              string blobTypeOfCall = string.Empty;

              string containerName = string.Empty;
              string blobName = string.Empty;
              string leaseAction = string.Empty;
              string leaseID = string.Empty;
              string eTag = string.Empty;
              string mimicDirectories = string.Empty;
              string includeSnapshots = string.Empty;
              string includeUncommitted = string.Empty;

              if (context.Request.Params.AllKeys.Contains("accountname"))
            accountName = context.Request.Params["accountname"].ToString();
              if (context.Request.Params.AllKeys.Contains("sharedkey"))
            sharedKey = context.Request.Params["sharedkey"].ToString().Replace(" ", "+");
              if (context.Request.Params.AllKeys.Contains("blobtypeofcall"))
            blobTypeOfCall = context.Request.Params["blobtypeofcall"].ToString();
              if (context.Request.Params.AllKeys.Contains("containername"))
            containerName = context.Request.Params["containername"].ToString();
              if (context.Request.Params.AllKeys.Contains("blobname"))
            blobName = context.Request.Params["blobname"].ToString();
              if (context.Request.Params.AllKeys.Contains("leaseaction"))
            leaseAction = context.Request.Params["leaseaction"].ToString().ToLower();
              if (context.Request.Params.AllKeys.Contains("leaseid"))
            leaseID = context.Request.Params["leaseid"].ToString();
              if (context.Request.Params.AllKeys.Contains("etag"))
            eTag = context.Request.Params["etag"].ToString();
              if (context.Request.Params.AllKeys.Contains("mimicdirectories"))
            mimicDirectories = "1";
              if (context.Request.Params.AllKeys.Contains("includesnapshots"))
            includeSnapshots = "1";
              if (context.Request.Params.AllKeys.Contains("includeuncommitted"))
            includeUncommitted = "1";

              string retVal = string.Empty;
              string retValType = string.Empty;
              retValType = "text/xml";

              Hashtable ht = new Hashtable();

              foreach (string key in context.Request.Params.AllKeys)
              {
            if (key.StartsWith("x-ms-meta-"))
              if (ht.ContainsKey(key))
            ht[key] = string.Format("{0},{1}", ht[key].ToString(), context.Request.Params[key].ToString());
              else
            ht.Add(key, context.Request.Params[key].ToString());
              }

              azureResults ar = new azureResults();
              Finsel.AzureCommands.AzureBlobStorage abs = new Finsel.AzureCommands.AzureBlobStorage(accountName,
            string.Format("http://{0}.blob.core.windows.net", accountName), sharedKey,
            "SharedKey");

              switch (blobTypeOfCall.ToLower())
              {
            case "addblobmetadata":
              ar = abs.MetaData(cmdType.put, containerName, blobName, ht);
              retVal = processAzureResults(ar);
              break;
            case "addcontainermetadata":
              ar = abs.MetaData(cmdType.put, containerName, "", ht);
              retVal = processAzureResults(ar);
              break;
            case "copyblob":
            //ar=abs.CopyBlob(
            case "createcontainer":
              ht.Add("x-ms-meta-CreatedBy", "Finsel.AzureCommands");
              ar = abs.Containers(cmdType.put, containerName, ht);
              retVal = processAzureResults(ar);
              break;
            case "deleteblob":
              ar = abs.DeleteBlob(containerName, blobName);
              retVal = processAzureResults(ar);
              break;
            case "deletecontainer":
              ar = abs.Containers(cmdType.delete, containerName, new Hashtable());
              retVal = processAzureResults(ar);
              break;
            case "deleteblobmetadata":
              ar = abs.MetaData(cmdType.put, containerName, blobName, null);
              retVal = processAzureResults(ar);
              break;
            case "deletecontainermetadata":
              ar = abs.MetaData(cmdType.put, containerName, "", null);
              retVal = processAzureResults(ar);
              break;
            case "displayblobmetadata":
              ar = abs.MetaData(cmdType.get, containerName, blobName, null);
              retVal = processAzureResults(ar);
              break;
            case "displaycontainermetadata":
              ar = abs.MetaData(cmdType.get, containerName, "", null);
              retVal = processAzureResults(ar);
              break;
            case "getblob":
              break;
            case "getbloblist":
              string parameterList = string.Empty;
              if (mimicDirectories == "1")
            if (blobName == string.Empty)
              parameterList = "delimiter=/";
            else
              parameterList = string.Format("prefix={0}&delimiter={1}", (blobName == string.Empty ? "/" : blobName), "/");
              if (includeSnapshots == "1")
              {
            if (parameterList != string.Empty)
              parameterList = string.Format("{0}&include=snapshots", parameterList);
            else parameterList = "include=snapshots";
              }
              if (includeUncommitted == "1")
              {
            if (parameterList != string.Empty)
              parameterList = string.Format("{0}&include=uncommittedblobs", parameterList);
            else parameterList = "include=uncommittedblobs";
              }
              ar = abs.GetBlobList(containerName, parameterList);
              retVal = processAzureResults(ar);
              break;
            case "getcontainerlist":
              ar = abs.GetContainerList(containerName);
              retVal = processAzureResults(ar);
              break;
            case "leaseblob":
              AzureBlobStorage.BlobLease bl;
              switch (leaseAction)
              {
            case "acquirelease": bl = AzureBlobStorage.BlobLease.acquireLease; break;
            case "breaklease": bl = AzureBlobStorage.BlobLease.breakLease; break;
            case "releaselease": bl = AzureBlobStorage.BlobLease.releaseLease; break;
            case "renewlease": bl = AzureBlobStorage.BlobLease.renewLease; break;
            default: bl = AzureBlobStorage.BlobLease.acquireLease; break;
              }

              ar = abs.LeaseBlob(containerName, blobName, bl, leaseID);
              retVal = processAzureResults(ar);
              break;
            case "makecontainerprivate":
              ar = abs.SetContainerAccess(containerName, false);
              retVal = processAzureResults(ar);
              break;
            case "makecontainerpublic":
              ar = abs.SetContainerAccess(containerName, true);
              retVal = processAzureResults(ar);
              break;

            case "snapshotblob":
              ar = abs.SnapshotBlob(containerName, blobName);
              retVal = processAzureResults(ar);
              break;
            case "verifyblob":
              ar = abs.CheckBlobCache(containerName, blobName, eTag);
              retVal = processAzureResults(ar);
              break;
            default:
              retVal = @"<!DOCTYPE html PUBLIC '-//W3C//DTD XHTML 1.0 Transitional//EN' 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd'>
            <html xmlns='http://www.w3.org/1999/xhtml' >
            <head>
            <title>Azure Architect Azure Blob Storage Handler Form</title>
            </head>
            <body>
            <form action='absHandler.ashx' method='post'>
            <table border='1'>
            <tr>
            <td>Account</td><td><input name='accountname' maxlength='100' /></td>
            </tr><tr>
            <td>Shared Key</td><td><input name='sharedkey' maxlength='100' /></td>
            </tr><tr>
            <td>Container Name</td><td><input name='containername' maxlength='100' /></td>
            </tr><tr>
            <td>Blob Name</td><td><input name='blobname' maxlength='1240' /></td>
            </tr><tr>
            <td>Type of call</td><td>
            <select name='blobtypeofcall'>
            <option>AddContainerMetadata</option>
            <option value='CreateContainer'>CreateContainer</option>
            <option value='DeleteBlob'>DeleteBlob</option>
            <option value='DeleteContainer'>DeleteContainer</option>
            <option value='DeleteContainerMetadata'>DeleteContainerMetadata</option>
            <option value='DisplayContainerMetadata'>DisplayContainerMetadata</option>
            <option value='GetBlob'>GetBlob</option>
            <option value='GetBlobList'>GetBlobList</option>
            <option value='GetContainerList'>GetContainerList</option>
            <option value='MakeContainerPrivate'>MakeContainerPrivate</option>
            <option value='MakeContainerPublic'>MakeContainerPublic</option></select>
            </td>
            </tr><tr>
            <td colspan='2'><input type='submit' /></td>
            </tr>
            </table>
            </form>
            </body>
            </html>";
              retValType = "text/html";
              //          retVal = @"<?xml version='1.0' encoding='utf-8' ?>
              //<ValidFormat>
              //  <!-- Post format -->
              //  <AccountName />
              //  <SharedKey />
              //  <ContainerName />
              //  <Blobname />
              //  <BlobTypeOfCall>
              //    <AddContainerMetadata />
              //    <CreateContainer />
              //    <DeleteBlob />
              //    <DeleteContainer />
              //    <DeleteContainerMetadata />
              //    <DisplayContainerMetadata />
              //    <GetBlob />
              //    <GetBlobList />
              //    <GetContainerList />
              //    <MakeContainerPrivate />
              //    <MakeContainerPublic />
              //  </BlobTypeOfCall>
              //</ValidFormat>";
              break;
              }

              context.Response.ContentType = retValType;
              context.Response.Write(retVal);
        }
Example #21
0
 private void btnSnapshotBlob_Click(object sender, EventArgs e)
 {
     this.Cursor = Cursors.WaitCursor;
     AzureBlobStorage abs = new AzureBlobStorage(txtAccount.Text, string.Format("http://{0}.queue.core.windows.net", txtAccount.Text), txtSharedKey.Text, "SharedKey");
     azureResults ar = abs.SnapshotBlob(cbBlobContainers.Text, cbBlobs.Text);
     ProcessResults(ar);
     this.Cursor = Cursors.Default;
 }
        public void processRequest(string queryName, NameValueCollection htKeys)
        {
            string retVal = string.Empty;
              XmlDocument xdoc = new XmlDocument();
              xdoc.LoadXml(new Utility().getConfigXML());
              XmlNode xNode = xdoc.SelectSingleNode(string.Format("//blobdata[@name='default']"));

              string azureAccount = xNode.Attributes["account"].Value;
              string azureEndpoint = xNode.Attributes["endpoint"].Value;
              string azureSharedKey = xNode.Attributes["accountSharedKey"].Value;
              string blobStorage = xNode.Attributes["endpoint"].Value;

              xNode = xdoc.SelectSingleNode(string.Format("//fragmentData/Setting[@name='HandlerFragments']"));
              string fragmentLocation = xNode.Attributes["value"].Value;
              try
              {
            AzureBlobStorage abs = new AzureBlobStorage(azureAccount, blobStorage, azureSharedKey, "SharedKey");
            azureResults ar = new azureResults();
            // Get the page name and replace the .q extension with .xml
            if (!queryName.ToLower().EndsWith(".xml"))
              queryName += ".xml";
            byte[] xmlFragment = abs.GetBlob(fragmentLocation, queryName, "", ref ar, "");
            if (!ar.Succeeded)
            {
              NotifyError(new Exception(ar.StatusCode.ToString()));
            }
            else
            {

              xdoc = new XmlDocument();
              System.Text.ASCIIEncoding enc = new System.Text.ASCIIEncoding();
              xdoc.LoadXml(enc.GetString(xmlFragment));
              /*
               * http://azure-architect.com/portals/16/MOOPData.xsd

               */
              XmlNode xn = xdoc.SelectSingleNode("//storedProcedure[1]");
              string storedProcedureName = xn.Attributes["procedureName"].Value;
              string connectionStringName = xn.Attributes["connectionName"].Value;

              SqlCommand cmd = new SqlCommand(storedProcedureName, new SqlConnection(new Utility().ResolveDataConnection(connectionStringName)));
              cmd.CommandType = CommandType.StoredProcedure;
              XmlNodeList xnl = xdoc.SelectNodes("/MOOPData/luceneData/field");
              Field.Store[] fieldStore = new Field.Store[xnl.Count];
              Field.Index[] indexType = new Field.Index[xnl.Count];
              string[] luceneName = new string[xnl.Count];
              string[] dataName = new string[xnl.Count];
              bool[] isIncludedInOlioSearchFlag = new bool[xnl.Count];
              bool[] isKeyFieldFlag = new bool[xnl.Count];
              string olioSearchFieldName = string.Empty;
              string azureContainerName = string.Empty;
              olioSearchFieldName = xdoc.SelectSingleNode("//MOOPData/luceneData/olioSearchFieldName[1]").InnerText;
              azureContainerName = xdoc.SelectSingleNode("//MOOPData/luceneData/azureContainer[1]").InnerText;
              for (int i = 0; i < xnl.Count; i++)
              {
            XmlNode node = xnl[i];
            switch (node.Attributes["store"].Value.ToLower())
            {
              case "compress": fieldStore[i] = Field.Store.COMPRESS; break;
              case "no": fieldStore[i] = Field.Store.NO; break;
              case "yes": fieldStore[i] = Field.Store.YES; break;
              default: fieldStore[i] = Field.Store.NO; break;
            }

            switch (node.Attributes["index"].Value.ToLower())
            {
              case "analyzed": indexType[i] = Field.Index.ANALYZED; break;
              case "analyzed_no_norms": indexType[i] = Field.Index.ANALYZED_NO_NORMS; break;
              case "no": indexType[i] = Field.Index.NO; break;
              case "no_norms": indexType[i] = Field.Index.NOT_ANALYZED_NO_NORMS; break;
              case "not_analyzed": indexType[i] = Field.Index.NOT_ANALYZED; break;
              case "not_analyzed_no_norms": indexType[i] = Field.Index.NOT_ANALYZED_NO_NORMS; break;
              case "tokenized": indexType[i] = Field.Index.ANALYZED; break;
              case "un_tokenized": indexType[i] = Field.Index.NOT_ANALYZED; break;
              default: indexType[i] = Field.Index.NO; break;
            }
            dataName[i] = node.Attributes["dataName"].Value;
            luceneName[i] = node.Attributes["luceneName"].Value;
            isKeyFieldFlag[i] = node.Attributes["isKeyField"].Value == "true";
            isKeyFieldFlag[i] = node.Attributes["isKeyField"].Value == "true";
            isIncludedInOlioSearchFlag[i] = node.Attributes["isIncludedInOlioSearch"].Value == "true";
              }

              xnl = xdoc.SelectNodes("//parameter");
              foreach (XmlNode node in xnl)
              {
            string parameterName = node.Attributes["parameterName"].Value;
            string urlParameterName = node.Attributes["urlParameterName"].Value;
            string dataType = node.Attributes["dataType"].Value;
            string dataLength = node.Attributes["dataLength"].Value;
            string defaultValue = node.Attributes["defaultValue"].Value;
            if (!parameterName.StartsWith("@"))
              parameterName = "@" + parameterName;
            SqlParameter sp = new SqlParameter();
            sp.ParameterName = parameterName;
            switch (dataType)
            {
              case "bigint": sp.SqlDbType = SqlDbType.BigInt; break;
              case "binary": sp.SqlDbType = SqlDbType.Binary; break;
              case "bit": sp.SqlDbType = SqlDbType.Bit; break;
              case "char": sp.SqlDbType = SqlDbType.Char; break;
              case "date": sp.SqlDbType = SqlDbType.Date; break;
              case "datetime": sp.SqlDbType = SqlDbType.DateTime; break;
              case "datetime2": sp.SqlDbType = SqlDbType.DateTime2; break;
              case "datetimeoffset": sp.SqlDbType = SqlDbType.DateTimeOffset; break;
              case "decimal": sp.SqlDbType = SqlDbType.Decimal; break;
              case "float": sp.SqlDbType = SqlDbType.Float; break;
              case "geography": sp.SqlDbType = SqlDbType.Structured; break;
              case "geometry": sp.SqlDbType = SqlDbType.Structured; break;
              case "hierarchyid": sp.SqlDbType = SqlDbType.Structured; break;
              case "image": sp.SqlDbType = SqlDbType.Image; break;
              case "int": sp.SqlDbType = SqlDbType.Int; break;
              case "money": sp.SqlDbType = SqlDbType.Money; break;
              case "nchar": sp.SqlDbType = SqlDbType.NChar; break;
              case "ntext": sp.SqlDbType = SqlDbType.NText; break;
              case "nvarchar": sp.SqlDbType = SqlDbType.NVarChar; break;
              case "real": sp.SqlDbType = SqlDbType.Real; break;
              case "smalldatetime": sp.SqlDbType = SqlDbType.SmallDateTime; break;
              case "smallint": sp.SqlDbType = SqlDbType.SmallInt; break;
              case "smallmoney": sp.SqlDbType = SqlDbType.SmallMoney; break;
              case "sql_variant": sp.SqlDbType = SqlDbType.Variant; break;
              case "text": sp.SqlDbType = SqlDbType.Text; break;
              case "time": sp.SqlDbType = SqlDbType.Time; break;
              case "timestamp": sp.SqlDbType = SqlDbType.Timestamp; break;
              case "tinyint": sp.SqlDbType = SqlDbType.TinyInt; break;
              case "uniqueidentifier": sp.SqlDbType = SqlDbType.UniqueIdentifier; break;
              case "varbinary": sp.SqlDbType = SqlDbType.VarBinary; break;
              case "varchar": sp.SqlDbType = SqlDbType.VarChar; break;
              case "xml": sp.SqlDbType = SqlDbType.Xml; break;
              default: sp.SqlDbType = SqlDbType.Variant; break;
            }
            switch (urlParameterName.ToLower())
            {
              case "ipaddress": sp.Value = "127.0.0.1"; break;
              case "domainname": sp.Value = ""; break;
              default: if (htKeys[urlParameterName] != null)
                  sp.Value = htKeys[urlParameterName];
                else
                  sp.Value = (defaultValue.ToLower() == "dbnull" ? DBNull.Value
                  : (object)defaultValue);
                break;
            }
            cmd.Parameters.Add(sp);
              }

              cmd.Connection.Open();
              SqlDataReader dr = cmd.ExecuteReader();
              Microsoft.WindowsAzure.StorageCredentialsAccountAndKey scaak = new Microsoft.WindowsAzure.StorageCredentialsAccountAndKey(azureAccount, azureSharedKey);
              Microsoft.WindowsAzure.CloudStorageAccount csa = new Microsoft.WindowsAzure.CloudStorageAccount(scaak, false);
              AzureDirectory azureDirectory = new AzureDirectory(csa, azureContainerName, new RAMDirectory());
              bool findexExists = false;
              try
              {
            findexExists = IndexReader.IndexExists(azureDirectory);
            if ((findexExists) && IndexWriter.IsLocked(azureDirectory))
              azureDirectory.ClearLock("write.lock");
              }
              catch (Exception e)
              {
            Trace.WriteLine(e.ToString());
            return;
              }

              IndexWriter idxW = new IndexWriter(azureDirectory, new SnowballAnalyzer("English"), !findexExists, new IndexWriter.MaxFieldLength(1024));
              idxW.SetRAMBufferSizeMB(10.0);
              idxW.SetUseCompoundFile(false);
              idxW.SetMaxMergeDocs(10000);
              idxW.SetMergeFactor(100);
              while (dr.Read())
              {
            StringBuilder olioSearch = new StringBuilder();
            Document doc = new Document();
            for (int i = 0; i <= dataName.GetUpperBound(0); i++)
            {

              if (isKeyFieldFlag[i])
              {

                NotifyCaller(string.Format("Processing {0}", dr[dataName[i]].ToString().ToLower()));
                idxW.DeleteDocuments(new Term(luceneName[i], dr[dataName[i]].ToString().ToLower()));
                doc.Add(new Field(luceneName[i], dr[dataName[i]].ToString().ToLower(), Field.Store.YES, Field.Index.NOT_ANALYZED));
              }
              else
                try
                {
                  doc.Add(new Field(luceneName[i], dr[dataName[i]].ToString(), fieldStore[i], indexType[i]));

                  if (isIncludedInOlioSearchFlag[i])
                    olioSearch.AppendFormat("\r\n{0}", dr[dataName[i]].ToString());
                }
                catch (Exception ex)
                {
                  NotifyError(ex);
                }
            }
            if (olioSearch.ToString() != string.Empty && olioSearchFieldName != string.Empty)
              doc.Add(new Field(olioSearchFieldName, olioSearch.ToString(), Field.Store.NO, Field.Index.ANALYZED));
            idxW.AddDocument(doc);
              }
              idxW.Commit();
              idxW.Close();

            }
              }

              catch (Exception ex)
              {
            MOOPFramework.FrameworkUtility u = new MOOPFramework.FrameworkUtility(new Utility().ResolveDataConnection("sqlAzureConnection"));
            u.LogData("localhost", "quoteSearchLoader", "testing", string.Empty, string.Empty, "", "QueryError", ex.ToString(),
              u.nvc2XML(htKeys));
            //retVal = string.Format("<!-- {0} -->", ex.ToString());
            NotifyError(new Exception("An error occured but it was logged for later review"));
              }
              finally { if (retVal == string.Empty) retVal = "<root />"; }
        }
Example #23
0
 private void btnVerifyBlob_Click(object sender, EventArgs e)
 {
     this.Cursor = Cursors.WaitCursor;
     System.Collections.Hashtable ht = new Hashtable();
     ht.Add("If-Modified", txtETag.Text);
     AzureBlobStorage abs = new AzureBlobStorage(txtAccount.Text, string.Format("http://{0}.queue.core.windows.net", txtAccount.Text), txtSharedKey.Text, "SharedKey");
     //azureResults ar =abs.CheckBlobCache(cbBlobContainers.Text, cbBlobs.Text, txtETag.Text);
     azureResults ar = new azureResults();
     abs.GetBlob(cbBlobContainers.Text, cbBlobs.Text, "", ref ar, txtETag.Text);
     ProcessResults(ar);
     this.Cursor = Cursors.Default;
 }
Example #24
0
 public void LoadBlobs()
 {
     if (FileFilter == string.Empty || FileFilter == null)
       FileFilter = "*";
        System.Collections.Hashtable metadata = new System.Collections.Hashtable();
        metadata.Add("loadingSource", "finsel.AzureBlobLoader");
        metadata.Add("dateLoaded",DateTime.Now.ToShortDateString());
        azureResults ar = new azureResults();
        AzureBlobStorage abs = new AzureBlobStorage(Account, EndPoint, SharedKey, "SharedKey");
        if (Container == "*")
        {
     foreach (string newContainer in Directory.GetDirectories(StartingDirectory))
     {
      Container = newContainer.Replace(StartingDirectory,"");
      if (Container.StartsWith(@"\")) Container = Container.Substring(1);
      ar = abs.Containers(cmdType.get, Container, new System.Collections.Hashtable());
      if (!ar.Succeeded)
       ar = abs.Containers(cmdType.put, Container, metadata);
      if(ar.Succeeded)
       ProcessDirectory(abs, metadata, newContainer, newContainer );
     }
     // Process $root
     ar = abs.Containers(cmdType.get, "$root%", new System.Collections.Hashtable());
     if (ar.Succeeded)
     ProcessDirectory(abs, metadata, StartingDirectory, "$root");
        }
        else
        {
     ar = abs.Containers(cmdType.get, Container, new System.Collections.Hashtable());
     if (!ar.Succeeded)
      ar = abs.Containers(cmdType.put, Container, metadata);
     ProcessDirectory(abs, metadata, StartingDirectory, StartingDirectory);
        }
 }
Example #25
0
        private void btnAddMetaData_Click(object sender, EventArgs e)
        {
            Hashtable ht = new Hashtable();
               string[] AllData = txtMetaData.Text.Split("\n".ToCharArray());
               foreach (string metadataDetail in AllData)
               {
            //string[] detail = metadataDetail.Split(":".ToCharArray());
            string metadataName = string.Empty;
            string metadataValue = string.Empty;
            if (metadataDetail.Contains(":"))
            {
             metadataName = metadataDetail.Substring(0, metadataDetail.IndexOf(":"));
             if (!metadataName.StartsWith("x-ms-meta-"))
               metadataName = "x-ms-meta-" + metadataName;
             if (metadataDetail.Length > metadataDetail.IndexOf(":"))
              metadataValue = metadataDetail.Substring(metadataDetail.IndexOf(":") + 1);
            }
            else
             metadataName = metadataDetail;

            if (metadataName != string.Empty)
            {

             metadataValue = metadataValue.Replace("\r", "");
             if (ht.ContainsKey(metadataName))
              ht[metadataName] = string.Format("{0},{1}", ht[metadataName].ToString(), metadataValue);
             else
              ht.Add(metadataName, metadataValue);
            }
               }
               AzureBlobStorage abs = new AzureBlobStorage(txtAccount.Text, string.Format("http://{0}.blob.core.windows.net", txtAccount.Text), txtSharedKey.Text, "SharedKey");
               azureResults ar = abs.MetaData(cmdType.put, cbBlobContainers.Text, cbBlobs.Text, ht);
               ProcessResults(ar);
        }
Example #26
0
 void ProcessDirectory(AzureBlobStorage abs, System.Collections.Hashtable metadata, string DirectoryPath, string startDirectory)
 {
     foreach(string fileName in Directory.GetFiles(DirectoryPath, FileFilter))
        {
     FileInfo fi = new FileInfo(fileName);
     // check whether a file has archive attribute
     bool isArchive = ((File.GetAttributes(fileName) & FileAttributes.Archive) == FileAttributes.Archive);
     if ((ArchiveAttributes && isArchive) || !ArchiveAttributes) // || (FilterOut != string.Empty && file))
     {
       string blobname = fi.Name;
       if (Directories)
     blobname = fileName.Replace(startDirectory, "").Replace(@"\", "/");
       if (blobname.StartsWith("/"))
     blobname = blobname.Substring(1);
       azureResults ar = abs.PutBlob(fi.Length, GetMimeType(fi.Extension),
        File.ReadAllBytes(fileName), Container, blobname, metadata);
       if (ar.Succeeded)
       {
     Console.WriteLine("Loaded: {0}", ar.Url);
     if (ArchiveAttributes)
       File.SetAttributes(fileName, File.GetAttributes(fileName) & ~(FileAttributes.Archive));
       }
       else
     Console.WriteLine("Error loading {0}\r\n\tStatus:{1}\r\n\r\n", blobname, ar.StatusCode);
     }
     if (ArchiveAttributes && !isArchive && verbose)
       Console.WriteLine("ArchiveAttribute Not Set on {0}", fileName);
        }
        foreach(string subdirectory in Directory.GetDirectories(DirectoryPath))
        {
     ProcessDirectory(abs,metadata, subdirectory, startDirectory );
        }
 }
Example #27
0
 private void btnCreateContainer_Click(object sender, EventArgs e)
 {
     this.Cursor = Cursors.WaitCursor;
        AzureBlobStorage abs = new AzureBlobStorage(txtAccount.Text, string.Format("http://{0}.blob.core.windows.net", txtAccount.Text), txtSharedKey.Text, "SharedKey");
        Hashtable htMetaData = new Hashtable();
        htMetaData.Add("x-ms-meta-createdBy", "Finsel.AzureCommands");
        azureResults ar = abs.Containers(cmdType.put, cbBlobContainers.Text, htMetaData);
        ProcessResults(ar);
        this.Cursor = Cursors.Default;
 }
Example #28
0
        private void btnGetBlobs_Click(object sender, EventArgs e)
        {
            this.Cursor = Cursors.WaitCursor;
               cbBlobs.Items.Clear();
               cbBlobs.Text = string.Empty;

               AzureBlobStorage abs = new AzureBlobStorage(txtAccount.Text, string.Format("http://{0}.blob.core.windows.net", txtAccount.Text), txtSharedKey.Text, "SharedKey");
               string parameterList = string.Empty;
               if (chkBlobDirectories.Checked)
             if (cbBlobs.Text == string.Empty)
               parameterList = "delimiter=/";
             else
               parameterList = string.Format("prefix={0}&delimiter={1}", (cbBlobs.Text == string.Empty ? "/" : cbBlobs.Text), "/");
               if (chkIncludeSnapshots.Checked)
               {
             if (parameterList != string.Empty)
               parameterList = string.Format("{0}&include=snapshots", parameterList);
             else parameterList = "include=snapshots";
               }
               if (chkUncommittedBlobs.Checked)
               {
             if (parameterList != string.Empty)
               parameterList = string.Format("{0}&include=uncommittedblobs", parameterList);
             else parameterList = "include=uncommittedblobs";
               }

               azureResults ar = abs.GetBlobList(cbBlobContainers.Text, parameterList);
               if (ar.Succeeded)
               {
            XmlDocument xdoc = new XmlDocument();
            xdoc.LoadXml(ar.Body);
            XmlNodeList nodes = xdoc.SelectNodes("//Blob");

            foreach (XmlNode node in nodes)
            {

              if (node.SelectSingleNode("Snapshot") == null)
            cbBlobs.Items.Add(node.SelectSingleNode("Name").InnerText);
              else
            cbBlobs.Items.Add( string.Format("{0}?snapshot={1}", node.SelectSingleNode("Name").InnerText, node.SelectSingleNode("Snapshot").InnerText));
            }
               }
               ProcessResults(ar);
               this.Cursor = Cursors.Default;
        }
Example #29
0
        void ProcessContainer(AzureBlobStorage abs, System.Collections.Hashtable metadata, string DirectoryPath, string ContainerName)
        {
            string baseDirectory = DirectoryPath + (DirectoryPath.EndsWith(@"\") ? "" : @"\") + ContainerName;
               if (!Directory.Exists(baseDirectory))
            Directory.CreateDirectory(baseDirectory);
               if(! baseDirectory.EndsWith(@"\"))
            baseDirectory = baseDirectory + @"\";

               azureResults arList = abs.GetBlobList(ContainerName, "");
               XmlDocument xdoc = new XmlDocument();
               xdoc.LoadXml(arList.Body);
               XmlNode xContainerInfo = xdoc.SelectSingleNode("//EnumerationResults [1]");
               string containerStart = xContainerInfo.Attributes["ContainerName"].Value;
               XmlNodeList xnl = xdoc.SelectNodes("//Url");

               foreach (XmlNode blobNode in xnl)
               {
            // get the relative path of the blob
            string baseName = blobNode.InnerText.Replace(baseDirectory, "");
            // get directory
            string relativeDirectory = baseName.Replace(containerStart,"");
            if(relativeDirectory.Contains("/"))
             relativeDirectory = relativeDirectory.Replace("/", @"\");
            // Get filename
            string fileName = blobNode.InnerText.Substring(blobNode.InnerText.LastIndexOf("/") + 1);
            relativeDirectory = relativeDirectory.Replace(fileName, "");
            fileName = baseDirectory + relativeDirectory + fileName;
            if (!Directory.Exists(baseDirectory + relativeDirectory))
             Directory.CreateDirectory(baseDirectory + relativeDirectory);
            azureResults arBlob = new azureResults();
            byte[] fileBytes = abs.GetBlob(ContainerName, blobNode.InnerText.Replace(containerStart,"") , "", ref arBlob);
            if (fileBytes == null)
             Console.WriteLine("Skipped {0}: 0 bytes", fileName);
            else
             File.WriteAllBytes(fileName, fileBytes);
            Console.WriteLine("Retrieved {0}", fileName);
            if (deleteAfterRetrieval)
            {
              abs.DeleteBlob(ContainerName, blobNode.InnerText.Replace(containerStart, ""));
            }
            // save

               }
        }
        public void ProcessRequest(HttpContext context)
        {
            Int64 expirationSeconds = 1;
              HttpCacheability hc = HttpCacheability.NoCache;

              try
              {
            string retVal = string.Empty;

            XmlDocument xdoc = new XmlDocument();
            xdoc.LoadXml(new Utility().getConfigXML());
            XmlNode xNode = xdoc.SelectSingleNode("//blobData[@name='default']");

            string azureAccount = xNode.SelectSingleNode("Setting[@name='account']").Attributes["value"].Value;
            string azureEndpoint = xNode.SelectSingleNode("Setting[@name='endpoint']").Attributes["value"].Value;
            string azureSharedKey = xNode.SelectSingleNode("Setting[@name='accountSharedKey']").Attributes["value"].Value;
            string blobStorage = azureEndpoint;

            xNode = xdoc.SelectSingleNode(string.Format("//fragmentData/Setting[@name='HandlerFragments']"));
            string fragmentLocation = xNode.Attributes["value"].Value;
            string queryName = string.Empty;

            SetCompression(context);

            try
            {
              AzureBlobStorage abs = new AzureBlobStorage(azureAccount, blobStorage, azureSharedKey, "SharedKey");
              azureResults ar = new azureResults();
              // Get the page name and replace the .q extension with .xml
              queryName = context.Request.Path;
              queryName = queryName.Substring(queryName.LastIndexOf("/") + 1);
              queryName = queryName.Substring(0, queryName.Length - 2) + ".xml";
              byte[] xmlFragment = abs.GetBlob(fragmentLocation, queryName, "", ref ar, "");
              if (!ar.Succeeded)
              {
            context.Response.StatusCode = (int)ar.StatusCode;
              }
              else
              {
            xdoc = new XmlDocument();
            System.Text.ASCIIEncoding enc = new System.Text.ASCIIEncoding();
            xdoc.LoadXml(enc.GetString(xmlFragment));
            /*
             * http://azure-architect.com/portals/16/MOOPData.xsd

             */
            XmlNode xn = xdoc.SelectSingleNode("//storedProcedure[1]");
            string storedProcedureName = xn.Attributes["procedureName"].Value;
            string connectionStringName = xn.Attributes["connectionName"].Value;
            string requirePost = xn.Attributes["requirePost"].Value;
            if ((requirePost == "true" || requirePost == "1") && context.Request.HttpMethod != "POST") // throw an error
            {
              context.Response.StatusDescription = "This page requires using the POST method";
              context.Response.StatusCode = 400; // Bad Request
            }
            else
            {
              SqlCommand cmd = new SqlCommand(storedProcedureName, new SqlConnection(new Utility().ResolveDataConnection( connectionStringName)));
              cmd.CommandType = CommandType.StoredProcedure;
              XmlNodeList xnl = xdoc.SelectNodes("//parameter");
              foreach (XmlNode node in xnl)
              {
                string parameterName = node.Attributes["parameterName"].Value;
                string urlParameterName = node.Attributes["urlParameterName"].Value;
                string dataType = node.Attributes["dataType"].Value;
                string dataLength = node.Attributes["dataLength"].Value;
                string defaultValue = node.Attributes["defaultValue"].Value;
                if (!parameterName.StartsWith("@"))
                  parameterName = "@" + parameterName;
                SqlParameter sp = new SqlParameter();
                sp.ParameterName = parameterName;
                switch (dataType)
                {
                  case "bigint": sp.SqlDbType = SqlDbType.BigInt; break;
                  case "binary": sp.SqlDbType = SqlDbType.Binary; break;
                  case "bit": sp.SqlDbType = SqlDbType.Bit; break;
                  case "char": sp.SqlDbType = SqlDbType.Char; break;
                  case "date": sp.SqlDbType = SqlDbType.Date; break;
                  case "datetime": sp.SqlDbType = SqlDbType.DateTime; break;
                  case "datetime2": sp.SqlDbType = SqlDbType.DateTime2; break;
                  case "datetimeoffset": sp.SqlDbType = SqlDbType.DateTimeOffset; break;
                  case "decimal": sp.SqlDbType = SqlDbType.Decimal; break;
                  case "float": sp.SqlDbType = SqlDbType.Float; break;
                  case "geography": sp.SqlDbType = SqlDbType.Structured; break;
                  case "geometry": sp.SqlDbType = SqlDbType.Structured; break;
                  case "hierarchyid": sp.SqlDbType = SqlDbType.Structured; break;
                  case "image": sp.SqlDbType = SqlDbType.Image; break;
                  case "int": sp.SqlDbType = SqlDbType.Int; break;
                  case "money": sp.SqlDbType = SqlDbType.Money; break;
                  case "nchar": sp.SqlDbType = SqlDbType.NChar; break;
                  case "ntext": sp.SqlDbType = SqlDbType.NText; break;
                  case "nvarchar": sp.SqlDbType = SqlDbType.NVarChar; break;
                  case "real": sp.SqlDbType = SqlDbType.Real; break;
                  case "smalldatetime": sp.SqlDbType = SqlDbType.SmallDateTime; break;
                  case "smallint": sp.SqlDbType = SqlDbType.SmallInt; break;
                  case "smallmoney": sp.SqlDbType = SqlDbType.SmallMoney; break;
                  case "sql_variant": sp.SqlDbType = SqlDbType.Variant; break;
                  case "text": sp.SqlDbType = SqlDbType.Text; break;
                  case "time": sp.SqlDbType = SqlDbType.Time; break;
                  case "timestamp": sp.SqlDbType = SqlDbType.Timestamp; break;
                  case "tinyint": sp.SqlDbType = SqlDbType.TinyInt; break;
                  case "uniqueidentifier": sp.SqlDbType = SqlDbType.UniqueIdentifier; break;
                  case "varbinary": sp.SqlDbType = SqlDbType.VarBinary; break;
                  case "varchar": sp.SqlDbType = SqlDbType.VarChar; break;
                  case "xml": sp.SqlDbType = SqlDbType.Xml; break;
                  default: sp.SqlDbType = SqlDbType.Variant; break;
                }
                switch (urlParameterName.ToLower())
                {
                  case "ipaddress": sp.Value = context.Request.UserHostAddress; break;
                  //case "domainname": sp.Value = context.Request.Url.DnsSafeHost; break;
                  case "domainname": sp.Value = context.Request.Headers["Host"]; break;
                  default: if (context.Request.Params[urlParameterName] != null)
                      sp.Value = context.Request.Params[urlParameterName];
                    else
                      sp.Value = (defaultValue.ToLower() == "dbnull" ? DBNull.Value
                      : (object)defaultValue);
                    break;
                }
                cmd.Parameters.Add(sp);
              }

              xnl = xdoc.SelectNodes("//cacheInformation[1]");
              foreach (XmlNode node in xnl)
              {
                if (node.Attributes["expireSeconds"] != null)
                  expirationSeconds = Convert.ToInt64(node.Attributes["expireSeconds"].Value);
                if (node.Attributes["cacheability"] != null)
                {
                  switch (node.Attributes["cacheability"].Value.ToLower())
                  {
                    case "nocache": hc = HttpCacheability.NoCache; break;
                    case "private": hc = HttpCacheability.Private; context.Response.Headers.Add("ETag", md5(context.Request.RawUrl)); break;
                    case "public": hc = HttpCacheability.Public; context.Response.Headers.Add("ETag", md5(context.Request.RawUrl)); break;
                    case "server": hc = HttpCacheability.Server; context.Response.Headers.Add("ETag", md5(context.Request.RawUrl)); break;
                    case "serverandnocache": hc = HttpCacheability.ServerAndNoCache; context.Response.Headers.Add("ETag", md5(context.Request.RawUrl)); break;
                    case "serverandprivate": hc = HttpCacheability.ServerAndPrivate; context.Response.Headers.Add("ETag", md5(context.Request.RawUrl)); break;
                    default: hc = HttpCacheability.NoCache; break;
                  }
                }
              }
              cmd.Connection.Open();
              SqlDataReader dr = cmd.ExecuteReader();
              while (dr.Read())
                retVal = retVal + dr[0].ToString();
              cmd.Connection.Close();
              if (!retVal.StartsWith("<?xml"))
              {
                retVal = "<?xml version=\"1.0\" encoding=\"iso-8859-1\" ?>" + retVal;
                retVal = retVal.Trim();
                context.Response.ContentType = "text/xml; charset=iso-8859-1";
              }
              string xmlTransform = string.Empty;
              try { xmlTransform = xdoc.SelectSingleNode("/MOOPData/storedProcedure/transform").InnerText; }
              catch { }
              if (xmlTransform != string.Empty && xmlTransform != null && !context.Request.Params.AllKeys.Contains("ignore_transform"))
              {
                  string transformContentType = "text/html";
                  try { transformContentType = xdoc.SelectSingleNode("/MOOPData/storedProcedure/transform").Attributes["contentType"].Value; }
                  catch { }
                  xmlFragment = abs.GetBlob(fragmentLocation, xmlTransform, "", ref ar, "");
                  if (ar.Succeeded)
                  {
                    XsltUtil xslu = new XsltUtil();
                      retVal = XsltUtil.TransformXml(retVal, System.Text.ASCIIEncoding.ASCII.GetString(xmlFragment));

                      context.Response.ContentType = transformContentType;
                  }

              }
              else
              {
                  // Check for JSon Request

                  MessageFormatOptions defaultOptions = new MessageFormatOptions();
                  string preferredContentType = string.Empty;
                  if (context.Request.HttpMethod == "GET" || context.Request.HttpMethod == "DELETE")
                  {
                      preferredContentType = (context.Request.AcceptTypes ?? new string[0])
                                .Select(m => m.Split(';')[0])
                                .FirstOrDefault(m => defaultOptions.MimeInputTypes.ContainsKey(m))
                                ?? defaultOptions.DefaultContentType;
                      if (preferredContentType.Trim() == string.Empty)
                          preferredContentType = context.Request.Headers["Content-Type"];
                  }
                  else preferredContentType = context.Request.Headers["Content-Type"];
                  if (preferredContentType == "application/json")
                  {
                      context.Response.ContentType = preferredContentType;
                      XmlDocument doc = new XmlDocument();
                      doc.LoadXml(retVal);
                      retVal = JsonConvert.SerializeXmlNode(doc);
                  }
                  else
                      context.Response.ContentType = "text/xml";
              }
            }
              }
            }
            catch (Exception ex)
            {
              FrameworkUtility u = new FrameworkUtility(new Utility().ResolveDataConnection("sqlAzureConnection"));
              FrameworkUtility.ParsedURI pUri = new FrameworkUtility.ParsedURI(context.Request.RawUrl);
              u.LogData(pUri.domainName, pUri.folderName, pUri.pageName, context.Request.HttpMethod, context.Request.UserHostAddress, "", "QueryError", ex.ToString(),
            u.nvc2XML(context.Request.Headers));
              //retVal = string.Format("<!-- {0} -->", ex.ToString());
              context.Response.StatusDescription = "An error occured but it was logged for later review";
              context.Response.StatusCode = 400;
            }
            finally { if (retVal == string.Empty) retVal = "<root />"; }

            context.Response.Cache.SetExpires(DateTime.Now.AddSeconds(expirationSeconds));
            context.Response.Cache.SetCacheability(hc);
            context.Response.Write(retVal);
              }
              catch (Exception ex)
              {
            context.Response.StatusCode = 404;
            context.Response.Close();
              }
        }