Exemplo n.º 1
0
func NewAzure(name string, info map[string]string) (Backend, error) {
	b := &azureBackend{
		name:      name,
		container: info["container"],
	}
	accountName := info["account_name"]
	accountKey := info["account_key"]

	if b.container == "" {
		return nil, fmt.Errorf("blobstore: missing Azure Storage container param for %s", name)
	}
	if accountName == "" {
		return nil, fmt.Errorf("blobstore: missing Azure Storage account_name param for %s", name)
	}
	if accountKey == "" {
		return nil, fmt.Errorf("blobstore: missing Azure Storage account_key param for %s", name)
	}

	client, err := storage.NewBasicClient(accountName, accountKey)
	if err != nil {
		return nil, fmt.Errorf("blobstore: error creating Azure Storage client %s: %s", name, err)
	}
	b.client = client.GetBlobService()

	ok, err := b.client.ContainerExists(b.container)
	if err != nil {
		return nil, fmt.Errorf("blobstore: error checking if Azure Storage container %q exists for %s: %s", b.container, name, err)
	}
	if !ok {
		return nil, fmt.Errorf("blobstore: Azure Storage container %q does not exists for %s", b.container, name)
	}

	return b, nil
}
Exemplo n.º 2
0
func TestAzureBackend(t *testing.T) {
	if os.Getenv("AZURE_ACCOUNT_NAME") == "" ||
		os.Getenv("AZURE_ACCOUNT_KEY") == "" {
		t.SkipNow()
	}

	accountName := os.Getenv("AZURE_ACCOUNT_NAME")
	accountKey := os.Getenv("AZURE_ACCOUNT_KEY")

	ts := time.Now().UnixNano()
	container := fmt.Sprintf("vault-test-%d", ts)

	cleanupClient, _ := storage.NewBasicClient(accountName, accountKey)

	logger := log.New(os.Stderr, "", log.LstdFlags)
	backend, err := NewBackend("azure", logger, map[string]string{
		"container":   container,
		"accountName": accountName,
		"accountKey":  accountKey,
	})

	defer func() {
		cleanupClient.GetBlobService().DeleteContainerIfExists(container)
	}()

	if err != nil {
		t.Fatalf("err: %s", err)
	}

	testBackend(t, backend)
	testBackend_ListPrefix(t, backend)
}
Exemplo n.º 3
0
func NewAzureClient(subscriptionID string, resourceGroupName string, storageAccountName string, servicePrincipalToken *azure.ServicePrincipalToken) (*AzureClient, error) {
	var azureClient = &AzureClient{}

	azureClient.DeploymentsClient = resources.NewDeploymentsClient(subscriptionID)
	azureClient.DeploymentsClient.Authorizer = servicePrincipalToken

	azureClient.GroupsClient = resources.NewGroupsClient(subscriptionID)
	azureClient.GroupsClient.Authorizer = servicePrincipalToken

	azureClient.PublicIPAddressesClient = network.NewPublicIPAddressesClient(subscriptionID)
	azureClient.PublicIPAddressesClient.Authorizer = servicePrincipalToken

	azureClient.VirtualMachinesClient = compute.NewVirtualMachinesClient(subscriptionID)
	azureClient.VirtualMachinesClient.Authorizer = servicePrincipalToken

	storageAccountsClient := armStorage.NewAccountsClient(subscriptionID)
	storageAccountsClient.Authorizer = servicePrincipalToken

	accountKeys, err := storageAccountsClient.ListKeys(resourceGroupName, storageAccountName)
	if err != nil {
		return nil, err
	}

	storageClient, err := storage.NewBasicClient(storageAccountName, *accountKeys.Key1)
	if err != nil {
		return nil, err
	}

	azureClient.BlobStorageClient = storageClient.GetBlobService()
	return azureClient, nil
}
Exemplo n.º 4
0
func uploadBlob(cl ExtensionsClient, storageAccount, packagePath string) (string, error) {
	// Fetch keys for storage account
	svc := storageservice.NewClient(cl.client)
	keys, err := svc.GetStorageServiceKeys(storageAccount)
	if err != nil {
		return "", fmt.Errorf("Could not fetch keys for storage account. Make sure it is in publisher subscription. Error: %v", err)
	}
	log.Debug("Retrieved storage account keys.")

	// Read package
	pkg, err := os.OpenFile(packagePath, os.O_RDONLY, 0777)
	if err != nil {
		return "", fmt.Errorf("Could not reach package file: %v", err)
	}
	stat, err := pkg.Stat()
	if err != nil {
		return "", fmt.Errorf("Could not stat the package file: %v", err)
	}
	defer pkg.Close()

	// Upload blob
	sc, err := storage.NewBasicClient(storageAccount, keys.PrimaryKey)
	if err != nil {
		return "", fmt.Errorf("Could not create storage client: %v", err)
	}
	bs := sc.GetBlobService()
	if _, err := bs.CreateContainerIfNotExists(containerName, storage.ContainerAccessTypeBlob); err != nil {
		return "", fmt.Errorf("Error creating blob container: %v", err)
	}
	blobName := fmt.Sprintf("%d.zip", time.Now().Unix())
	if err := bs.CreateBlockBlobFromReader(containerName, blobName, uint64(stat.Size()), pkg, nil); err != nil {
		return "", fmt.Errorf("Error uploading blob: %v", err)
	}
	return bs.GetBlobURL(containerName, blobName), nil
}
Exemplo n.º 5
0
func getBlobClient() (storage.BlobStorageClient, error) {
	api, err := storage.NewBasicClient(c.Conf.AzureAccount, c.Conf.AzureKey)
	if err != nil {
		return storage.BlobStorageClient{}, err
	}
	return api.GetBlobService(), nil
}
Exemplo n.º 6
0
func NewAzureClient(subscriptionID, resourceGroupName, storageAccountName string,
	servicePrincipalToken, servicePrincipalTokenVault *azure.ServicePrincipalToken) (*AzureClient, error) {

	var azureClient = &AzureClient{}

	maxlen := getInspectorMaxLength()

	azureClient.DeploymentsClient = resources.NewDeploymentsClient(subscriptionID)
	azureClient.DeploymentsClient.Authorizer = servicePrincipalToken
	azureClient.DeploymentsClient.RequestInspector = withInspection(maxlen)
	azureClient.DeploymentsClient.ResponseInspector = byInspecting(maxlen)
	azureClient.DeploymentsClient.UserAgent += packerUserAgent

	azureClient.GroupsClient = resources.NewGroupsClient(subscriptionID)
	azureClient.GroupsClient.Authorizer = servicePrincipalToken
	azureClient.GroupsClient.RequestInspector = withInspection(maxlen)
	azureClient.GroupsClient.ResponseInspector = byInspecting(maxlen)
	azureClient.GroupsClient.UserAgent += packerUserAgent

	azureClient.PublicIPAddressesClient = network.NewPublicIPAddressesClient(subscriptionID)
	azureClient.PublicIPAddressesClient.Authorizer = servicePrincipalToken
	azureClient.PublicIPAddressesClient.RequestInspector = withInspection(maxlen)
	azureClient.PublicIPAddressesClient.ResponseInspector = byInspecting(maxlen)
	azureClient.PublicIPAddressesClient.UserAgent += packerUserAgent

	azureClient.VirtualMachinesClient = compute.NewVirtualMachinesClient(subscriptionID)
	azureClient.VirtualMachinesClient.Authorizer = servicePrincipalToken
	azureClient.VirtualMachinesClient.RequestInspector = withInspection(maxlen)
	azureClient.VirtualMachinesClient.ResponseInspector = byConcatDecorators(byInspecting(maxlen), templateCapture(azureClient))
	azureClient.VirtualMachinesClient.UserAgent += packerUserAgent

	azureClient.AccountsClient = armStorage.NewAccountsClient(subscriptionID)
	azureClient.AccountsClient.Authorizer = servicePrincipalToken
	azureClient.AccountsClient.RequestInspector = withInspection(maxlen)
	azureClient.AccountsClient.ResponseInspector = byInspecting(maxlen)
	azureClient.AccountsClient.UserAgent += packerUserAgent

	azureClient.VaultClient = common.VaultClient{}
	azureClient.VaultClient.Authorizer = servicePrincipalTokenVault
	azureClient.VaultClient.RequestInspector = withInspection(maxlen)
	azureClient.VaultClient.ResponseInspector = byInspecting(maxlen)
	azureClient.VaultClient.UserAgent += packerUserAgent

	accountKeys, err := azureClient.AccountsClient.ListKeys(resourceGroupName, storageAccountName)
	if err != nil {
		return nil, err
	}

	storageClient, err := storage.NewBasicClient(storageAccountName, *accountKeys.Key1)
	if err != nil {
		return nil, err
	}

	azureClient.BlobStorageClient = storageClient.GetBlobService()
	return azureClient, nil
}
Exemplo n.º 7
0
func setup(t *testing.T, conf map[string]string) {
	creds, err := getCredentialsFromConf(conf)
	if err != nil {
		t.Fatalf("Error getting credentials from conf: %v", err)
	}
	rivieraClient, err := getRivieraClient(creds)
	if err != nil {
		t.Fatalf("Error instantiating the riviera client: %v", err)
	}

	// Create resource group
	r := rivieraClient.NewRequest()
	r.Command = riviera.CreateResourceGroup{
		Name:     conf["resource_group_name"],
		Location: riviera.WestUS,
	}
	response, err := r.Execute()
	if err != nil {
		t.Fatalf("Error creating a resource group: %v", err)
	}
	if !response.IsSuccessful() {
		t.Fatalf("Error creating a resource group: %v", response.Error.Error())
	}

	// Create storage account
	r = rivieraClient.NewRequest()
	r.Command = storage.CreateStorageAccount{
		ResourceGroupName: conf["resource_group_name"],
		Name:              conf["storage_account_name"],
		AccountType:       riviera.String("Standard_LRS"),
		Location:          riviera.WestUS,
	}
	response, err = r.Execute()
	if err != nil {
		t.Fatalf("Error creating a storage account: %v", err)
	}
	if !response.IsSuccessful() {
		t.Fatalf("Error creating a storage account: %v", response.Error.Error())
	}

	// Create container
	accessKey, err := getStorageAccountAccessKey(conf, conf["resource_group_name"], conf["storage_account_name"])
	if err != nil {
		t.Fatalf("Error creating a storage account: %v", err)
	}
	storageClient, err := mainStorage.NewBasicClient(conf["storage_account_name"], accessKey)
	if err != nil {
		t.Fatalf("Error creating storage client for storage account %q: %s", conf["storage_account_name"], err)
	}
	blobClient := storageClient.GetBlobService()
	_, err = blobClient.CreateContainerIfNotExists(conf["container_name"], mainStorage.ContainerAccessTypePrivate)
	if err != nil {
		t.Fatalf("Couldn't create container with name %s: %s.", conf["container_name"], err)
	}
}
Exemplo n.º 8
0
// Create a new StorageClient object based on a configuration file.
func (c *Config) NewClient() (dialects.StorageClient, error) {
	serviceClient, err := storage.NewBasicClient(c.Account, c.AccessKey)
	if err != nil {
		return nil, err
	}
	return &QueueStorage{
		Account:   c.Account,
		AccessKey: c.AccessKey,
		QueueName: c.QueueName,
		Client:    serviceClient.GetQueueService()}, nil
}
Exemplo n.º 9
0
// newAzureBackend constructs an Azure backend using a pre-existing
// bucket. Credentials can be provided to the backend, sourced
// from the environment, AWS credential files or by IAM role.
func newAzureBackend(conf map[string]string, logger log.Logger) (Backend, error) {

	container := os.Getenv("AZURE_BLOB_CONTAINER")
	if container == "" {
		container = conf["container"]
		if container == "" {
			return nil, fmt.Errorf("'container' must be set")
		}
	}

	accountName := os.Getenv("AZURE_ACCOUNT_NAME")
	if accountName == "" {
		accountName = conf["accountName"]
		if accountName == "" {
			return nil, fmt.Errorf("'accountName' must be set")
		}
	}

	accountKey := os.Getenv("AZURE_ACCOUNT_KEY")
	if accountKey == "" {
		accountKey = conf["accountKey"]
		if accountKey == "" {
			return nil, fmt.Errorf("'accountKey' must be set")
		}
	}

	client, err := storage.NewBasicClient(accountName, accountKey)

	if err != nil {
		return nil, fmt.Errorf("Failed to create Azure client: %v", err)
	}

	client.GetBlobService().CreateContainerIfNotExists(container, storage.ContainerAccessTypePrivate)

	maxParStr, ok := conf["max_parallel"]
	var maxParInt int
	if ok {
		maxParInt, err = strconv.Atoi(maxParStr)
		if err != nil {
			return nil, errwrap.Wrapf("failed parsing max_parallel parameter: {{err}}", err)
		}
		if logger.IsDebug() {
			logger.Debug("azure: max_parallel set", "max_parallel", maxParInt)
		}
	}

	a := &AzureBackend{
		container:  container,
		client:     client.GetBlobService(),
		logger:     logger,
		permitPool: NewPermitPool(maxParInt),
	}
	return a, nil
}
Exemplo n.º 10
0
func New(config Config) (result *comm, err error) {
	storageClient, err := storage.NewBasicClient(config.StorageAccountName, config.StorageAccountKey)
	if err != nil {
		return nil, err
	}
	config.blobClient = storageClient.GetBlobService()

	result = &comm{
		config: config,
	}
	return
}
Exemplo n.º 11
0
func (armClient *ArmClient) getQueueServiceClientForStorageAccount(resourceGroupName, storageAccountName string) (*mainStorage.QueueServiceClient, error) {
	key, err := armClient.getKeyForStorageAccount(resourceGroupName, storageAccountName)
	if err != nil {
		return nil, err
	}

	storageClient, err := mainStorage.NewBasicClient(storageAccountName, key)
	if err != nil {
		return nil, fmt.Errorf("Error creating storage client for storage account %q: %s", storageAccountName, err)
	}

	queueClient := storageClient.GetQueueService()
	return &queueClient, nil
}
Exemplo n.º 12
0
// getStorageClientForStorageService is helper method which returns the
// storage.Client associated to the given storage service name.
func (c Client) getStorageClientForStorageService(serviceName string) (storage.Client, error) {
	var storageClient storage.Client

	keys, err := c.storageServiceClient.GetStorageServiceKeys(serviceName)
	if err != nil {
		return storageClient, fmt.Errorf("Failed getting Storage Service keys for %s: %s", serviceName, err)
	}

	storageClient, err = storage.NewBasicClient(serviceName, keys.PrimaryKey)
	if err != nil {
		return storageClient, fmt.Errorf("Failed creating Storage Service client for %s: %s", serviceName, err)
	}

	return storageClient, err
}
Exemplo n.º 13
0
func initAzureStorage() error {
	var storageKey = os.Getenv("AZURE_STORAGE_ACCESS_KEY")
	var storageName = os.Getenv("AZURE_STORAGE_ACCOUNT")
	client, err := storage.NewBasicClient(storageName, storageKey)
	if err != nil {
		return err
	}

	blobService = client.GetBlobService()
	_, err = blobService.CreateContainerIfNotExists(containerName, storage.ContainerAccessTypePrivate)
	if err != nil {
		return err
	}

	return nil
}
Exemplo n.º 14
0
func (armClient *ArmClient) getBlobStorageClientForStorageAccount(resourceGroupName, storageAccountName string) (*mainStorage.BlobStorageClient, bool, error) {
	key, accountExists, err := armClient.getKeyForStorageAccount(resourceGroupName, storageAccountName)
	if err != nil {
		return nil, accountExists, err
	}
	if accountExists == false {
		return nil, false, nil
	}

	storageClient, err := mainStorage.NewBasicClient(storageAccountName, key)
	if err != nil {
		return nil, true, fmt.Errorf("Error creating storage client for storage account %q: %s", storageAccountName, err)
	}

	blobClient := storageClient.GetBlobService()
	return &blobClient, true, nil
}
Exemplo n.º 15
0
// Create a new StorageClient object based on a configuration file.
func (c *Config) NewClient() (dialects.StorageClient, error) {
	serviceClient, err := storage.NewBasicClient(c.Account, c.AccessKey)
	if err != nil {
		return nil, err
	}
	converterFunction, err := dialects.GetBatchConverterFunction(c.FileFormat)
	if err != nil {
		return nil, err
	}
	return &BlobStorage{
		Account:        c.Account,
		AccessKey:      c.AccessKey,
		BlobPath:       c.BlobPath,
		Container:      c.Container,
		FileFormat:     c.FileFormat,
		BatchConverter: converterFunction,
		Client:         serviceClient.GetBlobService()}, nil
}
func newVolumeDriver(accountName, accountKey, mountpoint, metadataRoot string, removeShares bool) (*volumeDriver, error) {
	storageClient, err := azure.NewBasicClient(accountName, accountKey)
	if err != nil {
		return nil, fmt.Errorf("error creating azure client: %v", err)
	}
	metaDriver, err := newMetadataDriver(metadataRoot)
	if err != nil {
		return nil, fmt.Errorf("cannot initialize metadata driver: %v", err)
	}
	return &volumeDriver{
		cl:           storageClient.GetFileService(),
		meta:         metaDriver,
		accountName:  accountName,
		accountKey:   accountKey,
		mountpoint:   mountpoint,
		removeShares: removeShares,
	}, nil
}
Exemplo n.º 17
0
func (c *AzureClient) createContainer(storageAccountName, primaryAccessKey, containerName string, containerAccessType storageclient.ContainerAccessType) error {
	storageClient, err1 := storageclient.NewBasicClient(storageAccountName, primaryAccessKey)
	if err1 != nil {
		fmt.Println("Creating storage client failed")
		return err1
	}

	blobStorageClient := storageClient.GetBlobService()
	ok, err2 := blobStorageClient.CreateContainerIfNotExists(containerName, containerAccessType)
	if err2 != nil {
		fmt.Println("Creating storage container failed")
		return err2
	}
	if !ok {
		fmt.Println("Storage container already existed")
	}

	return nil
}
Exemplo n.º 18
0
func azureFactory(conf map[string]string) (Client, error) {
	storageAccountName, ok := conf["storage_account_name"]
	if !ok {
		return nil, fmt.Errorf("missing 'storage_account_name' configuration")
	}
	containerName, ok := conf["container_name"]
	if !ok {
		return nil, fmt.Errorf("missing 'container_name' configuration")
	}
	keyName, ok := conf["key"]
	if !ok {
		return nil, fmt.Errorf("missing 'key' configuration")
	}

	accessKey, ok := confOrEnv(conf, "access_key", "ARM_ACCESS_KEY")
	if !ok {
		resourceGroupName, ok := conf["resource_group_name"]
		if !ok {
			return nil, fmt.Errorf("missing 'resource_group' configuration")
		}

		var err error
		accessKey, err = getStorageAccountAccessKey(conf, resourceGroupName, storageAccountName)
		if err != nil {
			return nil, fmt.Errorf("Couldn't read access key from storage account: %s.", err)
		}
	}

	storageClient, err := mainStorage.NewBasicClient(storageAccountName, accessKey)
	if err != nil {
		return nil, fmt.Errorf("Error creating storage client for storage account %q: %s", storageAccountName, err)
	}

	blobClient := storageClient.GetBlobService()
	leaseID, _ := confOrEnv(conf, "lease_id", "ARM_LEASE_ID")

	return &AzureClient{
		blobClient:    &blobClient,
		containerName: containerName,
		keyName:       keyName,
		leaseID:       leaseID,
	}, nil
}
Exemplo n.º 19
0
// newAzureBackend constructs an Azure backend using a pre-existing
// bucket. Credentials can be provided to the backend, sourced
// from the environment, AWS credential files or by IAM role.
func newAzureBackend(conf map[string]string, logger *log.Logger) (Backend, error) {

	container := os.Getenv("AZURE_BLOB_CONTAINER")
	if container == "" {
		container = conf["container"]
		if container == "" {
			return nil, fmt.Errorf("'container' must be set")
		}
	}

	accountName := os.Getenv("AZURE_ACCOUNT_NAME")
	if accountName == "" {
		accountName = conf["accountName"]
		if accountName == "" {
			return nil, fmt.Errorf("'accountName' must be set")
		}
	}

	accountKey := os.Getenv("AZURE_ACCOUNT_KEY")
	if accountKey == "" {
		accountKey = conf["accountKey"]
		if accountKey == "" {
			return nil, fmt.Errorf("'accountKey' must be set")
		}
	}

	client, err := storage.NewBasicClient(accountName, accountKey)

	if err != nil {
		return nil, fmt.Errorf("Failed to create Azure client: %v", err)
	}

	client.GetBlobService().CreateContainerIfNotExists(container, storage.ContainerAccessTypePrivate)

	a := &AzureBackend{
		container: container,
		client:    client.GetBlobService(),
		logger:    logger,
	}
	return a, nil
}
Exemplo n.º 20
0
// AcsInit sets up an Azure Client that can talk to the storage account
func AcsInit() (err error) {
	azureAccountName := os.Getenv("AZURE_STORAGE_ACCOUNT_NAME")
	if azureAccountName == "" {
		log.Error("You need to pass in environment variable AZURE_STORAGE_ACCOUNT_NAME")
		err = fmt.Errorf("Azure storage account name not configured")
		return
	}
	azureKey := os.Getenv("AZURE_STORAGE_ACCOUNT_KEY")
	if azureAccountName == "" {
		log.Error("You need to pass in environment variable AZURE_STORAGE_ACCOUNT_KEY")
		err = fmt.Errorf("Azure storage account key not configured")
		return
	}

	azureClient, err = storage.NewBasicClient(azureAccountName, azureKey)
	if err == nil {
		azureQueueClient = azureClient.GetQueueService()
	}

	azureInitialized = true
	return
}
func (s *StepSetProvisionInfrastructure) Run(state multistep.StateBag) multistep.StepAction {
	ui := state.Get("ui").(packer.Ui)
	client := state.Get(constants.RequestManager).(management.Client)

	errorMsg := "Error StepRemoteSession: %s"
	ui.Say("Preparing infrastructure for provision...")

	// get key for storage account
	ui.Message("Getting key for storage account...")

	keys, err := storageservice.NewClient(client).GetStorageServiceKeys(s.StorageAccountName)
	if err != nil {
		err := fmt.Errorf(errorMsg, err)
		state.Put("error", err)
		ui.Error(err.Error())
		return multistep.ActionHalt
	}

	//create storage driver
	s.storageClient, err = storage.NewBasicClient(s.StorageAccountName, keys.PrimaryKey)
	if err != nil {
		err := fmt.Errorf(errorMsg, err)
		state.Put("error", err)
		ui.Error(err.Error())
		return multistep.ActionHalt
	}

	//create temporary container
	s.flagTempContainerCreated = false

	ui.Message("Creating Azure temporary container...")
	err = s.storageClient.GetBlobService().CreateContainer(s.TempContainerName, storage.ContainerAccessTypePrivate)
	if err != nil {
		err := fmt.Errorf(errorMsg, err)
		state.Put("error", err)
		ui.Error(err.Error())
		return multistep.ActionHalt
	}

	s.flagTempContainerCreated = true

	isOSImage := state.Get(constants.IsOSImage).(bool)

	comm, err := azureVmCustomScriptExtension.New(
		azureVmCustomScriptExtension.Config{
			ServiceName:        s.ServiceName,
			VmName:             s.VmName,
			StorageAccountName: s.StorageAccountName,
			StorageAccountKey:  keys.PrimaryKey,
			ContainerName:      s.TempContainerName,
			Ui:                 ui,
			IsOSImage:          isOSImage,
			ManagementClient:   client,
		})

	if err != nil {
		err := fmt.Errorf(errorMsg, err)
		state.Put("error", err)
		ui.Error(err.Error())
		return multistep.ActionHalt
	}

	packerCommunicator := packer.Communicator(comm)

	state.Put("communicator", packerCommunicator)

	return multistep.ActionContinue
}
Exemplo n.º 22
0
func main() {
	acc := os.Getenv("AZURE_QUEUE_ACCOUNT_NAME")
	key := os.Getenv("AZURE_QUEUE_ACCOUNT_KEY")

	az, err := storage.NewBasicClient(acc, key)
	if err != nil {
		log.Println(err)
		return
	}

	blobs := az.GetBlobService()
	containerName := "gopload"
	created, err := blobs.CreateContainerIfNotExists(containerName, storage.ContainerAccessTypeContainer)
	if err != nil {
		log.Println(err)
		return
	}
	log.Println("container was created?", created)

	imagePath := `/Users/kenegozi/Dropbox/Photos/Ken/ken-2014-icon-head.jpg`
	imgData, err := ioutil.ReadFile(imagePath)
	if err != nil {
		log.Println(err)
		return
	}
	parameters := storage.PutBlockBlobParameters{
		CustomHeaders: map[string]string{}, //{"Content-Type": "image/jpeg", "x-ms-blob-content-type": "image/jpeg"},
	}

	parameters.ContentType = "slfkdm"

	typeofParams := reflect.TypeOf(parameters)
	valueofParams := reflect.ValueOf(parameters)
	for fix := 0; fix < typeofParams.NumField(); fix++ {
		headerValue := valueofParams.Field(fix).String()
		if headerValue == "" {
			continue
		}
		f := typeofParams.Field(fix)
		ftag := f.Tag
		headerTag := ftag.Get("header")
		aTag := ftag.Get("a")
		xTag := ftag.Get("x")
		log.Println("header z x", headerTag, aTag, xTag)

		if headerTag == "" {
			continue
		}
		headerNames := strings.Split(headerTag, ",")
		for _, hn := range headerNames {
			parameters.CustomHeaders[hn] = headerValue
		}
	}
	log.Printf("%#v\n", parameters)
	return
	//parameters.CustomHeaders["Content-Type"] = "image/jpeg"
	err = blobs.PutBlockBlob(containerName, "momo.jpg", uint64(len(imgData)), bytes.NewReader(imgData), parameters)
	if err != nil {
		log.Println(err)
		return
	}
	log.Println(blobs.GetBlobURL(containerName, "momo.jpg"))

}
Exemplo n.º 23
0
// GetStorageClient returns an Azure storage client, which can be used to retrieve service
// clients for blobs, files, and queues.
func GetStorageClient(storageAccount string, storageAccountKey string) storage.Client {
	cli, _ := storage.NewBasicClient(storageAccount, storageAccountKey)
	return cli
}
Exemplo n.º 24
0
func main() {
	cmd := cli.NewApp()
	cmd.Name = "azurefile-mounter"
	cmd.Version = "0.1"
	cmd.Usage = "Mount Azure File Service"
	var mountpoint, share string
	cmd.Flags = []cli.Flag{
		cli.StringFlag{
			Name:   "account-name",
			Usage:  "Azure storage account name",
			EnvVar: "AZURE_STORAGE_ACCOUNT",
		},
		cli.StringFlag{
			Name:   "account-key",
			Usage:  "Azure storage account key",
			EnvVar: "AZURE_STORAGE_ACCOUNT_KEY",
		},
		cli.StringFlag{
			Name:  "mountpoint",
			Usage: "Host path where volumes are mounted at",
			Value: mountpoint,
		},
		cli.StringFlag{
			Name:  "share",
			Usage: "Share Name",
			Value: share,
		},
	}
	cmd.Action = func(c *cli.Context) {
		accountName := c.String("account-name")
		accountKey := c.String("account-key")
		mountpoint := c.String("mountpoint")
		share := c.String("share")
		if accountName == "" || accountKey == "" {
			fmt.Println("azure storage account name and key must be provided.")
			return
		}
		if mountpoint == "" || share == "" {
			fmt.Println("mountpoint and share must be provided.")
			return

		}
		storageClient, err := azure.NewBasicClient(accountName, accountKey)
		if err != nil {
			fmt.Fprintf(os.Stderr, "error creating azure client: %v", err)
			return
		}
		cl := storageClient.GetFileService()
		// Create azure file share
		if _, err := cl.CreateShareIfNotExists(share); err != nil {
			fmt.Fprintf(os.Stderr, "error creating azure file share: %v", err)
			return
		}
		if err := os.MkdirAll(mountpoint, 0700); err != nil {
			fmt.Fprintf(os.Stderr, "could not create mount point: %v", err)
			return
		}
		cmd := exec.Command("mount", "-t", "cifs", fmt.Sprintf("//%s.file.core.windows.net/%s", accountName, share), mountpoint, "-o", fmt.Sprintf("vers=3.0,username=%s,password=%s,dir_mode=0777,file_mode=0777", accountName, accountKey), "--verbose")
		out, err := cmd.CombinedOutput()
		if err != nil {
			fmt.Fprintf(os.Stderr, "mount failed: %v \noutput=%s", err, string(out))
			return
		}
		return

	}
	cmd.Run(os.Args)
}
Exemplo n.º 25
0
func main() {
	app := cli.NewApp()
	app.Name = "blobxfer"
	app.Usage = "Upload files to Azure Blob Storage"
	app.Author = "Matthew Brown <*****@*****.**>"
	app.Version = "0.1.0"

	app.Flags = []cli.Flag{
		cli.StringFlag{
			Name:   "storageaccountkey",
			Value:  "",
			Usage:  "The storage account key to use",
			EnvVar: "STORAGE_ACCOUNT_KEY",
		},
	}
	app.Action = func(ctx *cli.Context) {

		if len(os.Args) != 4 {
			fmt.Errorf("blobxfer requires 3 command line arguments. Got %v", len(os.Args))
			os.Exit(1)
		}

		storageAccount := os.Args[1]
		container := os.Args[2]
		source := os.Args[3]

		fmt.Printf("Uploading %s to %s/%s\n", source, storageAccount, container)
		filelist, err := walkFiles(source, "")
		if err != nil {
			fmt.Errorf("Failed to open source: %s", err)
		}

		storageClient, err := storage.NewBasicClient(storageAccount, "")
		if err != nil {
			fmt.Errorf("Failed to create client: %s", err)
		}
		blobClient := storageClient.GetBlobService()

		for _, f := range filelist {
			blobURI := blobClient.GetBlobURL(container, f)
			fmt.Printf("Uploading: %s\n", blobURI)
			fd, err := os.Open(f)
			if err != nil {
				fmt.Errorf("Error reading file %s: %s", f, err)
				os.Exit(1)
			}
			defer fd.Close()

			err = blobClient.CreateBlockBlob(container, f)
			if err != nil {
				fmt.Errorf("Failed to create blobblock: %s", err)
				os.Exit(1)
			}

			err = putBlockBlob(blobClient, container, f, fd, storage.MaxBlobBlockSize)
			if err != nil {
				fmt.Errorf("Failed to put blob: %v", err)
				os.Exit(1)
			}
		}

	}
	app.Run(os.Args)
}