Fabric is a unified data architecture for the media and entertainment industry

Fabric

One of the most basic ways in which a project gets deployed is by SSHing into a remote host followed by executing a few basic commands. Apart from deployment, this can also be useful for running any command you want on a remote host, such as when a CI/CD pipeline is triggered. In this article I'll be taking a look on how to deploy a basic project to a remote server through Gitlab CI using Python Fabric. What is Fabric? is an open source python library that is used to execute commands remotely over SSH. Fabric Fabric is compatible with Python 2 and 3. To use it with Python3, install it with: pip3 install fabric Since the end goal here is to use fabric in an automated deployment pipeline, you don't actually need to have fabric installed on your local machine (unless that is where your pipeline runs). Installing fabric also installs the binary stub, which essentially allows fabric to read and execute commands defined in a file called the fabfile. fab Creating a fabfile Create a file named and start out with the following code: fabfile.py fabric task print( ) from import @task : def deploy (ctx) "Inside the task!" This defines a task called "deploy" which can be passed as an argument to the fab binary for execution. The decorator (Which is the Python equivalent of a closure - a subroutine that takes another subroutine as a parameter or returns another subroutine.) is used to convert the function to a task that can be executed by the fab binary. The function must take a context argument, which is given as in this case. @task deploy ctx On executing this by running from the same directory as , "Inside the task!" will be printed as the output. fab deploy fabfile.py Now to use this to do what Fabric is intended for - connecting a remote host and executing commands in it. fabric Connection, task Connection( ) c: c.cd( ):
            c.run( )
            c.run( )
            c.run( ) from import @task : def deploy (ctx) with "HOST" as with "/home/project/path/" "docker-compose down" "git pull origin master --recurse-submodules --rebase" "docker-compose up --build -d" Here, replace with the name or IP address of the host to which you are establishing a connection. From there, you can execute any command that the user as which you are logged in has permission to do. is used to ensure the remaining commands are executed from that particular folder. The commands I have given after this with are just examples. Replace them with what you need to execute. HOST c.cd() c.run() In this example I'm making use of Python context managers with the help of blocks, but there are many other ways to do this as well. You can read up on the to explore other ways to do this. with Fabric documentation By now you might have noticed just the host name is often not enough to establish a connection. What about the username and the private key to establish an SSH connection? This isn't immediately obvious, but because Fabric uses a library called under the hood for handling the SSH side of things, we can pass arguments to Paramiko's method by using the argument in Fabric's Connection. This looks like the following: Paramiko SSHclient.connect connect_kwargs fabric Connection, task Connection( ,
        user= ,
        connect_kwargs={ : }
    ) c: c.cd( ):
            c.run( )
            c.run( )
            c.run( ) from import @task : def deploy (ctx) with "HOST" "USERNAME" "key_filename" "~/.ssh/your_key" as with "/home/project/path/" "docker-compose down" "git pull origin master --recurse-submodules --rebase" "docker-compose up --build -d" Paramiko's takes a argument, which specifies the filename of the key to be used. Now you are passing all the info required to establish a connection via SSH. SSHclient.connect key_filename You can also pass the SSH key as an instance of Paramiko's class, or make use of a bunch of other options, which you can find in . pkey.Pkey Paramiko's documentation Of course, it's much safer to load all of these as environment variables. When using Gitlab CI, while setting the environment variables you can choose to make the key available as a file instead of a string, which is needed to make it work with the argument. key_filename Here is a screenshot of the Variables section under Gitlab CI/CD settings with the hostname added as a string and the key added as a file. You might want to load these values in other ways depending on how your team is organized and as per your security requirements. With these environment variables in place, the fabfile changes to this: os fabric Connection, task Connection(
        os.environ[ ],
        user= ,
        connect_kwargs={ : os.environ[ ]},
    ) c: c.cd( ):
            c.run( )
            c.run( )
            c.run( ) import from import @task : def deploy (ctx) with "HOST" "USERNAME" "key_filename" "DEPLOY_KEY_FILE" as with "/home/project/path/" "docker-compose down" "git pull origin master --recurse-submodules --rebase" "docker-compose up --build -d" Setting up Gitlab CI Now that the fabfile is ready, executing it with the Python Fabric package is all we have to do. This can be done in any way you want - manually, using Github actions, etc. Here I have an example of running it with Gitlab's CI. To do this, create a file at the project root. An example is given below: .gitlab-ci.yml image: "python:3.6" stages: - deploy deploy_to_production: stage: deploy script: - pip3 install fabric - fab deploy only: - master This is a basic configuration file that should be easy to understand if you're familiar with Gitlab's CI. It just has one job called that executes two things (It uses a Python 3 image as base): to install Fabric, and , which makes Fabric read our and execute the task named "deploy" in it. deploy_to_production pip3 install fabric fab deploy fabfile.py Conclusion Fabric has quite a lot more options than what is outlined here - such as dealing with sending the sudo password to the remote host when it's required, dealing with multiple hosts etc. It's worth going through their if you're planning to make use of it. documentation In conclusion, this is a really simple and effective way to programmatically build scripts to be executed over SSH and trigger them from common methods such as through a CI/CD tool. I hope you found this post useful. You can find me on and . Twitter LinkedIn

Deployment Automation via SSH With Python Fabric: How It Works

Automatización de la implementación a través de SSH con Python Fabric: cómo funciona

One of the biggest pains of getting started with Fabric, even though it's a powerful framework, is getting the infrastructure to work. This small tutorial will get you up and running in less than minutes. No script. No pain. I'm still surprised how hard it is for some people to get started with Fabric, I know that many just quit because they feel like it's not worth it. is a tool to create immutable setups for with just one command. Hurley development blockchain networks Just be sure you meet Fabric requirements: NodeJS 8.1x - install if you have a latter version. NVM If you are using Ubuntu or other Linux distros it may be good to follow this guide: https://docs.worldsibu.com/article/120-install-on-ubuntu Install (CE). Docker Community Edition Install the CLI tool: npm install -g @worldsibu/hurley All good so far? Now to create a network you need to do: hurl new This will create a default network in your local Docker. Two organizations Two peers, one CouchDB each What if you want more organizations or channels? hurl new -o 3 -c 3 This will create 3 organizations with three channels ready to be used. Beware that Hurley creates immutable setups, once you deploy the network you can't change the environment through the tool. You can manually do it, but I'd advice against it, for development you want something clean and easy to start/kill in a predictable way. Hurley not only manages your development network but also helps you installing your chaincode and calling it. Get into the source code of your project to install it like. If using golang: hurl install yourchaincode golang If using node: hurl install yourchaincode node Haven't bootstrapped your own project yet? I'm leaving some instructions at the end of this file on how to create a new project for nodejs with Convector in the section "Actual example with a new chaincode". Once you have installed your chaincode you can send transactions like this: hurl invoke yourchaincode invoke "param" You send the params as an array separated by a blank space. Actual example with a new chaincode: npm i -g @worldsibu/convector-cli conv new example example npm install npm run cc:package -- example org1 hurl new hurl install example node -P ./chaincode-example hurl invoke example example_create # Install a tool to bootstrap your project # Create a new smart contract code project # get to the project to see the source code cd # Resolve dependencies # Package the project # Start your blockchain network # Install the smart contract # Wait a few seconds # Send the first transaction '{"id":"1", "name": "example", "created": 1000, "modified": 10000}' Now you can go to the CouchDB installed by Hurley to see the resulting data of the transaction: http://localhost:5084/_utils/#database/ch1_example/_all_docs Other interesting content for you once using Hurley: How to find logs in the network? . Explore the blocks content Next steps Looking for a great open-source community to ask, grow, and share? , there are hundreds of devs interacting everyday. Join the Discord channel is the creator of and it's provided under an Apache 2.0 license. Here's the source code if you'd like to check it out. WorldSibu Hurley

Hyperledger Fabric: create a Blockchain Network in under 10 minutes [no scripts]

Overview Fabric is one of the Hyperledger projects hosted by the Linux Foundation. It provides a framework to develop blockchain applications. Since the release of Fabric 1.0 in this July, people are eager to build applications using Fabric to solve their business problems. However, many encounter difficulties in deploying and managing the Fabric system due to the complexity of Fabric in configuration. To simplify the operation of Fabric, we need some tools to help us better manage the distributed system of Fabric. Kubernetes seems ideal for this purpose for several reasons. (It is interesting to note that Kubernetes is a flagship project under CNCF, which is also a Linux Foundation project.) First, Fabric’s bits are built into container images. Its chaincode (smart contract) also leverages container to run in a sandbox. The Fabric system consists of components running in multiple containers. On the other hand, Kubernetes is becoming the dominant platform to automate the deployment, scaling, and other management of containerized applications. There is a natural fit of the two. Second, Fabric components can achieve high availability by deploying on Kubernetes. Kubernetes has a feature called replicator, which monitors running pods and brings up crashed ones automatically. Third, Kubernetes supports multi-tenancy. We can run multiple isolated Fabric instances on the same Kubernetes platform. This facilitates the development and testing of blockchain applications. In the following sections, we introduce a way to deploy Fabric on Kubernetes. We assume readers have basic knowledge of Fabric, Docker container and Kubernetes. Network Topology Our network topology is shown in Figure 1. The physical network is represented by blue lines. Kubernetes has one or more master and worker nodes. Besides that, we have a CMD machine as a client to issue the deployment commands. An NFS server is used as a shared file system for configuration files and other data. All these nodes are connected by a physical network (e.g. 192.168.0.1/24). Kubernetes’ network model enables all pods to connect to each other directly regardless which node they are on. By using Kubernetes’ CNI addons, such as Flannel, it’s easy to create an overlay network for this purpose. As indicated by the red lines in Figure 1 (some details of flannel components are omitted), Kubernetes connects all pods to the Flannel network, allowing containers of those pods to communicate with each other properly. The IP address range of the Flannel network, as well as the IP address of the kube_dns can be specified in the add-on configuration file. We need to make sure the IP address of kube_dns must be in the specified address range. In Figure 1, for example, the Flannel network is 10.0.0.1/16, and the kube_dns address is 10.0.0.10. Figure 1 Mapping Fabric Components to Kubernetes Pods Figure 2 Fabric is a distributed system which contains multiple nodes. The nodes could belong to different entities. As shown in Figure 2, each organization has its own set of nodes (For simplicity, not all nodes are shown). There is also a public consensus service formed by Orderers. To deploy Fabric onto Kubernetes, we need to convert all components into pods for deployment and use namespace to segregate organizations. In Kubernetes, namespace is an important concept. It is used to divide cluster resources between multiple users. In the case of Fabric, organizations can be mapped into namespaces so that they have their dedicated resource. After this mapping, peers of each organization can be distinguished by domain name. Furthermore, we could isolate different organizations by setting network policy (not covered in this blog). As shown in Figure 2, suppose there are N peer organizations and M orderer organizations in the Fabric network. Here’s how we divide them on Kubernetes: If Fabric, we assign the N-th peer organization with a name . Its corresponding namespace in Kubernetes is also called . All components of Fabric will be placed into namespace in Kubernetes. There are multiple pods under each organization’s namespace. A pod is a deployment unit in Kubernetes, it consists of one or more containers. We can bundle Fabric containers of each organization into several pods. These pod types are as follows: A) orgN orgN orgN orgN including Fabric peer, couchDB (optional), representing the organization’s peer node. Each organization could have one or more peer pods. Peer Pod: Fabric CA Server node of the organization. Usually one pod is needed in an organization. CA Server Pod: (optional) Provides an environment for command-line tools to manipulate the nodes of the organization. Fabric’s peer environment variables are configured in this pod. CLI Pod: Figure 3 There could be one or more orderers in Fabric. We set the name of the M-th orderer organization to . Its corresponding namespace on Kubernetes is . It has one or more pods to run the orderer node(s). B) orgordererM orgordererM Figure 4 If Kafka is used for consensus process, we can put Kafka into a separate namespace. It is only used to run and manage Zookeeper and Kafka containers. C) Putting it altogether, the overall deployment would look like below: Figure 5 Shared storage Before we deploy Fabric, we need to prepare configuration files of its components, such as peers and orderers. This is a very complicated process and tends to be error prone. Fortunately, we created a tool to automate the generation of these configuration files. The generated files are stored in a shared file system like NFS. When we later launch the pods of Fabric, we mount different subsets of configuration files into pods so that they have configuration specific to the organization they belong to. In Kubernetes, we can mount files or directories into a pod by using Persistent Volume (PV) and Persistent Volume Claim (PVC). We create PVs and PVCs for each organization in Fabric for resource isolation. Each organization should only see its own directory in NFS server. After the creation of PV, we define PVC so that Fabric nodes can consume PV to access the corresponding directories and files. Take peer organization org1 as an example. At first, we create a namespace org1 and its PV. The PV is mapped to the directory on NFS. Secondly, we create a PVC to consume the PV. All pods under the namespace org1 use the same PVC. However, we only map necessary files into each pod by specifying the mounting path in the pod configuration file. /opt/share/crypto-config/peerOrganizations/org1 Figure 6 shows the relationship between pods and their shared directory of NFS. Variable $PVC represents the PVC mount point, which is in this example. /opt/share/crypto-config/peerOrganizations/org1 Figure 6 Communication between Fabric components When all Fabric’s components are placed into Kubernetes’ pods, we need to consider the network connectivity between these pods. Each pod in Kubernetes has an internal IP address, but it is hard to use IP and port to communicate between pods because the IP address is ephemeral to the pod. When the pod gets restarted, its IP address gets changed too. Therefore, it is necessary to create services in Kubernetes for pods so that they can talk to each other through service name. The naming of a service should follow the principles to show the pod information that it binds to: The namespace of the service and the pod should be consistent. The name of the service should be consistent with the id of the container within the pod. 1) 2) Fabric’s peer0 of organization org1, for example, is mapped to a pod named peer0 under namespace org1. The service binding to it should be named peer0.org1, where peer0 is the name of the service and org1 is the namespace of the service. Other pods can connect to the peer0 of org1 by service name peer0.org1, which appears as peer0’s hostname. Work around the chaincode sandbox When a peer in Fabric instantiates a chaincode, it creates a Docker container in which the chaincode runs. The Docker API endpoint it invokes to create the container is unix:///var/run/docker.sock . This mechanism works well as long as the peer container and the chaincode container are managed by the same Docker engine. However, in Kubernetes, the chaincode container is created by the peer without notifying Kubernetes. Hence the chaincode and peer containers cannot connect to each other which results in failure when instantiating the chaincode. To work around this problem, we need to add the Kube_dns IP address in each worker node’s Docker engine. This ensures the chaincode container can resolve the peer’s hostname(service name) correctly by using the Kube_dns service. To do that, add in the below option in Docker engine’s configuration file, which is usually in Ubuntu 14.04. You may need to create this file if it does not exist. Please note, in latest version of Docker and some Linux Distro, the way to set docker daemon option may vary. Refer to Docker’s document for more details. /etc/default/docker In the below example, 10.0.0.10 is the IP address of kube_dns pod. Replace it with the right value in your environment. DOCKER_OPTS= Up to now, we have illustrated the key points in deploying Fabric onto Kubernetes. In the next post, we will describe detailed steps of the deployment. For people who cannot wait, please download our Fling “ ” to get a feel of how it works. It is an automation tool that allows you to deploy Fabric on Kubernetes with minimum configuration. The Fling shows you how to deploy Kubernetes on vSphere. If you do not use vSphere, you can choose whatever underlying infrastructure for your Kubernetes instance. Just skip the steps to deploy Kubernetes on vSphere. Feel free to let us know what you think. Blockchain on Kubernetes Continued with Part 2: https://medium.com/@zhanghenry/how-to-deploy-hyperledger-fabric-on-kubernetes-2-751abf44c807 Related post: Hyperledger Fabric Deployment Using Helm Chart About the Authors: Chief Architect of VMware China R&D, founder of ( ) — an open source container registry server. Henry is a co-author of the book “ ”. He is also a contributor of . Twitter: @zhanghaining Henry Zhang: Project Harbor https://github.com/goharbor Blockchain Technical Guide Hyperledger Cello project Engineer at VMware China R&D. He holds a master degree from Guangzhou University. He is a maintainer of Hyperledger Cello project. Luke Chen:

How to Deploy Hyperledger Fabric on Kubernetes (1)

Recently I started building a mobile app for iOS, thanks to 👻. Since most of the things are new, I thought I’ll write about my learnings while figuring out each thing. React Native This is the first post in the series, hope I can write more under this. What Here I am going to talk about how I implemented Single Sign-on with React Native. Why Personalizing a service is an important aspect of any . This could be done by asking the user to authenticate.There are couple of ways to do it: application 1. Web view Web view is a way of opening a browser in the app and asking the user for credentials to authenticate and then after completion redirect the user back to the app. This method was quick for me to implement, I followed the guide in the official documentation . here 2. Single Sign-on (SSO) SSO is a service that permits a user to use one set of login credentials (e.g., name and password) to access multiple applications. The service authenticates the end user for all the applications the user has been given rights to and eliminates further prompts when the user switches applications during the same session. For more information you can follow it here How Like everyone first I started to look for guides on how to do it and I did find couple of them, some were too specific to xcode and some had lot of manual changes. But at the end I did figure out and here I am going to explain how I implemented it. 1. Create React App and when you run you should have the below screen react-native init SSOExample react-native run-ios 2. Install Fabric into the app Go to signup if you are not a member already and download the SDK. https://get.fabric.io/ After signing in into the SDK select your xcode project then select Twitter kit to install and follow the instructions given in the app Go to to create your app so that you can obtain API key and secret. Twitter Apps Update the keys in the xcode project under Fabric like shown in the image below. or you can update from directly. info.plist 3. Add a Login with Twitter button I add the following code to create a new button which when clicked should trigger the login 4. Expose SSO module Since React Native doesn’t have SSO module yet, I needed to implement it in the native and access it from JavaScript. Open and add 2 new files under . SSOExample.xcodeproj Libraries This is an header file that implements the protocol. If you are wondering, RCT is an abbreviation of ReaCT. **_TwitterSignin.h_** RCTBridgeModule This is an Objective-C file. In addition to implementing the protocol, the class must also include the macro. This takes an optional argument that specifies the name that the module will be accessible as in your JavaScript code. If you do not specify a name, the JavaScript module name will match the Objective-C class name. **_TwitterSignin.m_** RCTBridgeModule RCT_EXPORT_MODULE() Since React Native invokes native modules methods on a separate serial GCD queue and this might change, I wanted to specify to use main-thread-only. This is done using . - (dispatch_queue_t)methodQueue React Native will not expose any methods of to JavaScript unless explicitly told to. This is done using the macro: TwitterSignin RCT_EXPORT_METHOD() Here we are creating a method which takes a callback as a parameter which gets triggered when the sign-on is completed, either success or failure. logIn For more you can visit the official guide . here 5. Trigger from JavaScript That’s it now when the login button is clicked I trigger method which was created above. logIn method is accessed using of . LogIn NativeModules react-native Thanks for reading, If you liked this article, click “Recommend” or write a response below. You can connect with me on Twitter . @narendra_shetty Other articles written by me: _This post is about my learning on performance techniques used to make Uber mobile web using React as fast as possible._hackernoon.com How I built a super fast Uber clone for mobile web _So in the past few months there is a lot of fuss going on in Javascript community about React and Redux. Everyone is…_crowdfire.engineering How I learnt Redux concepts _We have always thought of finding a way to share anything instantly from anywhere. The idea was to have something so…_crowdfire.engineering How We Built The Fastest Extension for Chrome

How to Single Sign-on with React Native and Fabric

This paper is available on arxiv under CC 4.0 license. Authors: (1) Terence Blésin, Institute of Physics, Swiss Federal Institute of Technology Lausanne (EPFL) & Center of Quantum Science and Engineering (EPFL); (2) Wil Kao, Institute of Physics, Swiss Federal Institute of Technology Lausanne (EPFL) & Center of Quantum Science and Engineering (EPFL); (3) Anat Siddharth, Institute of Physics, Swiss Federal Institute of Technology Lausanne (EPFL) & Center of Quantum Science and Engineering (EPFL); (4) Alaina Attanasio, OxideMEMS lab, Purdue University; (5) Hao Tian, OxideMEMS lab, Purdue University; (6) Sunil A. Bhave, OxideMEMS lab, Purdue University; (7) Tobias J. Kippenberg, Institute of Physics, Swiss Federal Institute of Technology Lausanne (EPFL) & Center of Quantum Science and Engineering (EPFL). Table of Links Introduction Results A. Physics and design B. Device characterization C. Bidirectional microwave-optical transduction D. Pulsed transduction Discussion Acknowledgments Appendix A: Theory Appendix B: Fabrication process flow Appendix C: Optical characterization Appendix D: Characterization of acoustic resonances Appendix E: Characterization of bidirectional transduction Appendix F: Optimization of optical extraction efficiency Appendix B: Fabrication process flow The piezoelectric actuators are monolithically integrated on Si3N4 waveguides, fabricated using the photonic Damascene process [7, 8]. The 850-nm-thick Si3N4 film is deposited using low-pressure chemical vapor deposition into the Damascene preform, with 2.8 µm thermal oxide below the waveguides. After annealing to drive hydrogen impurities out of the Si3N4 layer, 2.1-µm-thick TEOS oxide and 1.0-µm-thick low-temperature oxide top claddings are deposited and subsequently annealed. The metallic and piezoelectric films—95 nm of Mo, 1.0 µm of AlN and another 95 nm of Mo—are sputtered through foundry services provided by Plasma-Therm [9]. They are then patterned using deep reactive ion etching (DRIE) to form the actuators, ground planes and integrated heaters. We employ the same BandAid process as in Ref. [10] to localize the electrodes atop the suspended cladding. In particular, when connecting the Al feedline to the top electrode by a lift-off process, the bottom electrode is etched back using XeF2 to avoid shortcircuiting the electrodes. The process to suspend the cladding in the vicinity of the actuator is combined with the chip singulation steps of the Damascene process. First, a hole is opened in the middle of the donut-shaped actuator. The chip facets are simultaneously defined where trenches in the SiO2 are etched by C4F8 DRIE between neighboring chips. A second photolithography is performed to protect the facets while leaving the etched holes exposed for further processing, resulting in narrower trenches between chips. The Si substrate is then isotropically etched with SF6 until the SiO2 cladding below the actuator is suspended [11]. Following cladding suspension, the Si substrate is etched anisotropically until the desired chip thickness of 250 µm is reached. A final isotropic Si etch removes the parts of the substrate protruding from the SiO2 facet, providing proper access to the bus waveguide nanotapers with lensed fibers, or even using the butt-coupling scheme. To facilitate this last step, we employ ion-beam etching at a 20◦ tilt angle to remove the passivation layer formed on the hole sidewalls during the Si DRIE. The chips are ultimately released by grinding the back side of the wafer. This convoluted process ensures that all the actuators on the wafer are fully suspended, while the chip facets do not become exceedingly fragile from the undercut.

Bidirectional Microwave-optical Transduction Based on Integration: Appendix B: Fabrication

Scientific American Supplement, No. 717, September 28, 1889, by Various, is part of the HackerNoon Books Series. You can jump to any chapter in this book . NATURE, COMPOSITION, AND TREATMENT OF ANIMAL AND VEGETABLE FABRICS. here NATURE, COMPOSITION, AND TREATMENT OF ANIMAL AND VEGETABLE FABRICS. The inseparable duties of studying the composition of the various animal and vegetable fabrics, as also their nature—when in contact with the various mineral, vegetable, animal, and gaseous bodies applied in the individual industries—should not devolve upon the heads, chemists, or managers of firms alone. It is most important that every intelligent workman, whom we cannot expect to acquire a very extensive knowledge of chemistry and perfect acquaintance of the particular nature and component parts of fabrics, should, at least, be able to thwart the possibility of the majority of accidents brought about in regard to the quality and aspect of materials treated by them. In the treatment of wool the first operations are of no mean importance, and the whole subsequent operations and final results, almost as a whole, depend on the manner in which the fleece washing had been effected. In presence of suintine, as also fatty matters, as well as the countless kinds of acids deposited on the wool through exudation from the body, etc., the various agents and materials cannot act and deposit as evenly as might be desired, and the complete obliteration of the former, therefore, becomes an absolute necessity. For vegetable fabrics a great technical and practical knowledge is already requisite in their cultivation itself, and before any operations are necessary at all. One of the greatest points is the ripeness of the fibers. It is almost an impossibility to produce delicate colors on vegetable fabrics which were gathered inopportunely. Numerous experiments have been made on cotton containing smaller or larger quantities of unripe fibers, and after the necessary preceding operations, have been dyed in rose, purple, and blue colors, and the beauty of the shades invariably differed in proportion to the greater or lesser quantities of unripe fibers contained in the samples, and by a careless admixture of unripe and unseasoned fibers the most brilliant colors have been completely spoiled in the presence of the former. These deficiencies of unripe vegetable fibers are so serious that the utmost precautions should be taken, not only by planters to gather the fibers in a ripe state, but the natural aspect of ripe and unripe fibers and their respective differences should be known to the operators of the individual branches in the cotton industry themselves. The newest vegetable fabrics, as (China grass), pina, , or Manila hemp, , jute, and that obtained from the palm tree, must be tended with equal care to that of cotton. The , or China grass, is obtained from the , as also from the less known . The fibers of this stalk, after preparing and bleaching, have the whiteness of snow and the brilliancy of silk. By a special process—the description of which we must for the present leave in abeyance—the China grass can be transformed into a material greatly resembling the finest quality of wool. The greatest advantage afforded in the application of China grass is, moreover, that the tissues produced with this fiber are much more easily washed than silks, and in this operation they lose none of their beauty or their quality. ma abaca agave ma Boehmeria nivea Boehmeria puya The is produced from the fibrous parts of the bark of the wild banana tree, found in the Philippines. Its botanical denomination is . The fiber is not spun or wrung, but is jointed end to end. The threads are wound and subsequently beaten for softening, and finally bleached by plunging in lime water for twenty-four hours, and dried in the sun. abaca Musa troglodytarum abaca The is a fiber obtained from the leaf of the anana tree ( ), and is prepared in the same way as the abaca, but extreme care must in this case be observed in culling the fibers, in order to sort in accordance with their degree of fineness. pina Bromelias ananas The Arabs manufacture the stuff for their tents with a mixture of camel's hair and the fibrous flocks (kind of wadding) obtained from the stalks of the wafer palm (the ). Chamærops humilis The tissues used by the Arabs are coarse and colored, but the palm fibers—when freed from gluten, which makes them adhere more strongly—are susceptible to divide in a most astonishing manner. The is a coarse fiber, mostly used in France for the manufacture of Gobelin carpets and the production of ropes. Great efforts have been made to bleach it in a satisfactory manner, as is done with the , but the former kind of fiber resists the ordinary treatment with lyes, etc., and an appropriate bleaching process has only been discovered quite recently. Agave americana Phormium tenax Jute, which by many is confounded with , or New Zealand lint, is a fiber which can be divided as finely as desired, and can be most beautifully bleached. Phormium tenax The jute or Indian is generally known as a fibrous and textile fabric, obtained chiefly from Calcutta, and is similar in nature to the , an Oriental species, known in Oriental India by the name of and . This fibrous plant has the property of dividing into the finest parallel fibers, which can be carded without difficulty, and may be said to have the excellent properties of linen, hemp, and cotton at once. When properly bleached, it has an aspect which is as beautiful as that of silk. A mixture of silk and jute can be easily worked together, and can also be mixed with such vegetable fibers as cotton and linen. An immense quantity of flannel and other stuffs are now manufactured and imitated with the different mixtures containing jute. paat Corchorus capsularis hatta jute gheenatlapaat The is a fiber of a plant in the form of a cane ( ), and the paat or is the thread of a species of spiral ( ), sold under the name of jute tissues. suun Crotalaria juncea suncheepaat Corchorus olitarius The cotton tissues lose about twenty-five per cent. of their weight in bleaching, five per cent. of the substances are dissolved through alkalies, and the other twenty per cent., which are not attacked directly through the alkalies, are removed through chlorine, acids, and the water itself. The linen and hemp tissues contain eighteen per cent. of substances which are soluble in alkalies, and they lose from twenty-seven to thirty per cent. of their weight when taken through the consecutive bleaching operations. The substances do not alone include the substances contained in the fabric originally, but also such as are deposited in the preliminary treatment of the fabrics, as dirt from the hands of the operator, and gluten soluble in warm water; as also glue or gelatine, potash or soda, starch, albumen, and sugar, used by weavers, etc., and which are all soluble in water; further, such as greasy matters, calcareous soap, coppery soap, resinous or gummo-resinous matters, and the yellow and green coloring matters contained in textile fabrics, which are soluble in caustic soda; and finally, the earthy constituents which are soluble in acids. The nature and composition of silk and wool is diametrically opposed to that of the former. The silk is more of a gummy nature, and is susceptible to decompose into a kind of gelatinous mass if specially treated. The yellow coloring principle in silk was found only to be contained in a very small proportion, and consisting of several distinct bodies. The wool contains, first, a fatty matter which is solid at an ordinary temperature, and perfectly liquid at 60° C.; secondly, a fatty matter which is liquid at 15° C.; thirdly, a fibrous substance which essentially constitutes the wool in the strict sense of the word. The wool at least contains three important principles, as it will be known that the fibrous substance disengages sulphur and hydro-sulphuric acid without losing its peculiar properties; and it, therefore, appears probable that the sulphur entered as an element in the composition of a body which is perfectly distinct from the fibrous substance aforementioned. In treating wool with nitric acid, and taking all possible precautions to determine as accurately as possible the quantity of sulphuric acid produced by the contents of sulphur in the wool by the reaction with chloride of barium, it will be found to contain from 1.53 to 1.87 per cent. of sulphur.— Wool and Textile Fabrics. About HackerNoon Book Series: We bring you the most important technical, scientific, and insightful public domain books. This book is part of the public domain. Various (2006). Scientific American Supplement, No. 717, September 28, 1889. Urbana, Illinois: Project Gutenberg. Retrieved https://www.gutenberg.org/cache/epub/17755/pg17755-images.html This eBook is for the use of anyone anywhere at no cost and with almost no restrictions whatsoever. You may copy it, give it away or re-use it under the terms of the Project Gutenberg License included with this eBook or online at , located at . www.gutenberg.org https://www.gutenberg.org/policy/license.html

NATURE, COMPOSITION, AND TREATMENT OF ANIMAL AND VEGETABLE FABRICS

Scientific American Supplement, No. 799, April 25, 1891 by Various, is part of the HackerNoon Books Series. You can jump to any chapter in this book . STARCHES FOR THE FINISHING OF COTTON FABRICS. here STARCHES FOR THE FINISHING OF COTTON FABRICS. The starches have been classified by Dr. Muter, according to the appearance they give under the microscope, into five groups: .—Hilum and concentric rings visible. All the granules, oval or ovate. Tous-le-mois, potato, arrowroot, etc. Class I .—The concentric rings are all but invisible, the hilum is stellate. Maize, pea, bean, etc. Class II .—The concentric rings are all but invisible, also the hilum in the majority of granules. Wheat, barley, rye, chestnut, etc. Class III .—All the granules truncated at one end. Sago, tapioca, etc. Class IV .—All the granules angular in form. Rice, tacca, arrowroot, oats, etc. Class V The principal starches used for finishing cotton fabrics are potato (farina), wheat, Indian corn (maize), rice, tapioca, arrowroot, sago; the last three not so often as those previously named. About HackerNoon Book Series: We bring you the most important technical, scientific, and insightful public domain books. This book is part of the public domain. Various (2004). Scientific American Supplement, No. 799, April 25, 1891. Urbana, Illinois: Project Gutenberg. Retrieved https://www.gutenberg.org/cache/epub/11649/pg11649-images.html This eBook is for the use of anyone anywhere at no cost and with almost no restrictions whatsoever. You may copy it, give it away or re-use it under the terms of the Project Gutenberg License included with this eBook or online at , located at . www.gutenberg.org https://www.gutenberg.org/policy/license.html

STARCHES FOR THE FINISHING OF COTTON FABRICS

Fabric.js is a powerful library for handling Canvas interactions and rendering. While it's already a performant library, there are certain techniques you can employ to further improve the interaction and rendering speed. In this article, we will explore some valuable tips for optimizing performance in Fabric.js. Content Overview Utilize renderonAddRemove EnlivenObjects instead of loadFromJSON Optimize by excluding non-interactive shapes Utilize fabric.StaticCanvas Fine-tune object properties Enable object caching Use requestAnimationFrame Minimize Redraws Use object grouping Limit object complexity Use event delegation for interactivity Optimize rendering performance with fabric.util.requestRenderAll() Optimize image loading with lazy loading Dispose of unused objects and canvases Utilize renderOnAddRemove One of the recommended tips for optimizing performance in Fabric.js is to set the property to false when initializing the canvas. By adding to the fabric.Canvas constructor, you prevent Fabric from rerendering the entire canvas whenever an object is added or removed. renderOnAddRemove { renderOnAddRemove: false } This significantly improves performance during the initial load when adding multiple shapes to the canvas. const canvas = new fabric.Canvas("myId", { renderOnAddRemove: false });
canvas.renderAll(); // Call this whenever you want changes to be visible on the canvas EnlivenObjects instead of loadFromJSON While is a useful function for JSON to the canvas, it has some drawbacks. It clears the canvas before loading the JSON objects and automatically calls renderAll, which can be inefficient if you have additional operations to perform afterward. loadFromJSON deserializing Instead, you can use the function to parse the serialized Fabric.js JSON and add the objects to the canvas manually. enlivenObjects The rendering can be controlled more easily this way. const canvas = new fabric.Canvas("myId", { renderOnAddRemove: false });
fabric.util.enlivenObjects([{}, {}, {}], (objs) => {
    objs.forEach((item) => {
        canvas.add(item);
    });
    canvas.renderAll(); // Make sure to call this once you're ready!
}); Optimize by excluding non-interactive shapes Imagine you have a Fabric.js canvas with multiple shapes, but some of them are static and don't need to be interacted with. You can convert those non-interactive layers into image representations. Here's an example: // Convert non-interactive layers to images
var nonInteractiveLayer = new fabric.Rect({
    width: 200,
    height: 200,
    fill: 'red'
});
var image = new Image();
image.src = canvas.toDataURL('png');

// Render the image as an HTML <img> tag
document.body.appendChild(image);

// Overlay the canvas on top of the image
canvas.setOverlayImage(image, canvas.renderAll.bind(canvas)); By rendering non-interactive layers as images, you reduce the workload on Fabric.js and improve performance. Utilize fabric.StaticCanvas If you don't need interactivity in your canvas, you can use fabric.StaticCanvas instead of . fabric.Canvas Here's an example: // Create a static canvas
var staticCanvas = new fabric.StaticCanvas('myCanvas');

// Add objects to the static canvas
var rect = new fabric.Rect({
    width: 100,
    height: 100,
    fill: 'blue'
});
staticCanvas.add(rect);

// Perform other operations on the static canvas
// ...

// Render the static canvas
staticCanvas.renderAll(); Using instead of improves performance by avoiding the rendering of controls, borders, and corner detection. fabric.StaticCanvas fabric.Canvas Fine-tune object properties To optimize performance, you can fine-tune certain properties of objects in Fabric.js. Here are some examples: // Disable selection for an object
object.selectable = false;

// Disable controls and borders for an object
object.hasControls = false;
object.hasBorders = false;

// Disable rotating point for an object
object.hasRotatingPoint = false;

// Disable selection for the entire canvas
canvas.selection = false;

// Toggle skipTargetFind for mouse movement optimization
canvas.skipTargetFind = true; // or false, depending on your needs By adjusting these properties, you can improve performance by avoiding unnecessary rendering of controls, borders, and object corner detection during mouse movement. Enable object caching Fabric.js provides automatic object caching, where objects are pre-painted on an offscreen canvas and then copied onto the main canvas during the rendering process. Object caching can significantly improve performance, especially when dealing with complex objects or large SVGs. By default, object caching is enabled in Fabric.js. You can customize the caching behavior using the following properties: : When set to , objects are cached on an additional canvas. By default, this property is for browsers and for Node.js. objectCaching true true false : When set to , Fabric.js checks object properties for cache invalidation. If disabled, you may need to manually invalidate the cache when necessary. By default, this property is . statefulCache true false : When set to , cache regeneration is disabled during scaling operations. This can help avoid blurry effects during scaling. By default, this property is . noScaleCache true true : This flag indicates whether the object's cache needs to be rerendered. It is automatically set to after cache regeneration. dirty false : A function that, when returning , forces the object to have its own isolated cache, even if it is inside a group. By default, this function returns . needsItsOwnCache true false Please note that the specific properties mentioned in the article may vary depending on the Fabric.js version you are using. Use requestAnimationFrame To ensure smooth and efficient animation in Fabric.js, use the function to update the canvas. Syncing this function with the browser's rendering engine results in better performance and smoother animations. requestAnimationFrame Here's an example: function animate() {
  // Update canvas and objects here

  // Request the next animation frame
  fabric.util.requestAnimFrame(animate);
}

// Start the animation
animate(); By using , you optimize the animation performance in Fabric.js. requestAnimationFrame Minimize Redraws To avoid unnecessary redraws and improve performance, use the property to track changes and selectively render only the objects that need updating. It is especially useful when you have a large canvas with a lot of objects on it. dirty Here's an example: // Set an object as dirty to indicate changes
object.dirty = true;

// Render only dirty objects
canvas.renderAll();

// Reset dirty state after rendering
object.dirty = false; By minimizing redraws to only the necessary objects, you optimize performance in Fabric.js. Use object grouping When you have multiple objects that are frequently updated together or share common properties, consider grouping them using . Grouping objects reduces the number of individual objects that Fabric.js needs to render and update, improving performance. fabric.Group You can still interact with and manipulate the grouped objects as a single entity. Here's an example: // Create objects
var rect1 = new fabric.Rect({
    width: 50,
    height: 50,
    fill: 'red'
});
var rect2 = new fabric.Rect({
    width: 50,
    height: 50,
    fill: 'blue'
});

// Group objects
var group = new fabric.Group([rect1, rect2]);

// Add group to the canvas
canvas.add(group); Limit object complexity If you have complex objects with a large number of points, paths, or patterns, consider simplifying or optimizing them to improve performance. Simplifying the geometry or reducing the number of points in paths can significantly reduce the rendering and manipulation time for those objects. Additionally, avoid using overly large or high-resolution images as object fills or patterns, as they can slow down the rendering process. Use event delegation for interactivity With Fabric.js, you can respond to user interactions, such as clicks, mouse movements, and keyboard inputs. However, attaching event listeners to each individual object on the canvas can become inefficient, especially with a large number of objects. To optimize performance, you can utilize event delegation. Instead of attaching event listeners to each object, you attach a single event listener to the canvas itself and use event delegation to handle the events. of using event delegation for mouse clicks: Here's an example canvas.on('mouse:down', function(event) {
  var target = event.target;
  // Handle the click event on the target object
  if (target) {
    // Do something with the clicked object
  }
}); By using event delegation, you reduce the number of event listeners and improve performance, especially when dealing with a complex canvas with many interactive objects. Remember to adjust the event types and event handling based on your specific requirements, such as 'mouse:move', 'mouse:up', or other relevant events for the interactions you want to support in your application. Optimize rendering performance with fabric.util.requestRenderAll() Fabric.js provides a utility function called that can be used to optimize rendering performance, especially when you have multiple changes happening on the canvas simultaneously. fabric.util.requestRenderAll() Instead of calling multiple times after each change, you can use to batch the rendering calls and ensure efficient rendering. canvas.renderAll() fabric.util.requestRenderAll() Here's an example: fabric.util.requestRenderAll(); // Request rendering for all changes

// Make multiple changes to the canvas
object1.set({
    left: 100,
    top: 100
});
object2.set({
    fill: 'blue'
});
object3.remove();

// Call renderAll() once after making all the changes
canvas.renderAll(); By using , you optimize rendering performance by avoiding unnecessary intermediate rendering calls and ensuring that the final rendering is done efficiently. fabric.util.requestRenderAll() Use canvas.renderAll() or canvas.requestRenderAll() at the appropriate point in your code to trigger actual canvas rendering. Optimize image loading with lazy loading If your canvas contains a large number of images or complex image assets, loading all of them upfront can slow down the initial rendering process. To improve performance, consider implementing lazy loading techniques for image assets. Lazy loading involves loading images only when they are needed or when they come into the viewport. By deferring the loading of images that are initially out of view or not immediately required, you can reduce the initial load time and improve the overall performance of your Fabric.js canvas. of lazy loading images in Fabric.js Here's an example var imageElement = document.createElement('img');
imageElement.src = 'path/to/image.jpg';

// Add the image to the canvas when needed
imageElement.onload = function() {
    var fabricImage = new fabric.Image(imageElement);
    canvas.add(fabricImage);
}; By dynamically loading images when necessary, you can optimize the performance of your canvas and provide a smoother user experience, especially when dealing with large or numerous image assets. Remember to handle any error cases and implement appropriate fallback mechanisms to ensure that images are still loaded correctly even if lazy loading fails for any reason. Implementing lazy loading for images can be particularly beneficial when dealing with complex applications or scenarios where image assets are fetched dynamically based on user interactions or specific events. Dispose of unused objects and canvases When you no longer need certain objects or canvases in your Fabric.js application, it's important to dispose of them properly to free up memory and improve performance. Canvas objects that are no longer needed should be removed from the canvas by calling the method. canvas.remove(object) To properly dispose of canvas objects that are no longer in use, call . This will release any resources associated with the canvas and improve memory management. canvas.dispose() Here's an example: // Remove an object from the canvas
canvas.remove(object);

// Dispose of a canvas
canvas.dispose(); By disposing of unused objects and canvases, you prevent unnecessary memory usage and improve the overall performance of your Fabric.js application. It's important to regularly check your code for any objects or canvases that are no longer needed and properly dispose of them. This practice helps maintain a lean and efficient application, especially when dealing with large or complex scenarios. Conclusion In conclusion, Fabric.js is a powerful library for Canvas interactions and rendering. To optimize its performance, you can employ the following techniques: : Set the renderOnAddRemove property to false when initializing the canvas to prevent the entire canvas from being rerendered when objects are added or removed. Utilize renderOnAddRemove : Instead of using loadFromJSON, use enlivenObjects to manually add serialized JSON objects to the canvas, giving you more control over rendering and additional operations after loading. Use enlivenObjects instead of loadFromJSON : Convert non-interactive layers into image representations to reduce the workload on Fabric.js. Render those layers as images and overlay the canvas on top. Optimize by excluding non-interactive shapes : If interactivity is not needed, use fabric.StaticCanvas instead of fabric.Canvas to avoid rendering controls, borders, and corner detection. Utilize fabric.StaticCanvas : Adjust object properties like selection, controls, borders, rotating points, and canvas selection to optimize performance. Fine-tune object properties : Take advantage of automatic object caching in Fabric.js to improve performance for complex objects or large SVGs. Customize caching behavior using properties like , , , , and . Enable object caching objectCaching statefulCache noScaleCache dirty needsItsOwnCache : Use to update the canvas for smooth and efficient animation. Use requestAnimationFrame requestAnimationFrame : Use the property to track changes and selectively render only the objects that need updating. Minimize redraws dirty : Group objects together using fabric.Group to reduce the number of individual objects that need rendering and updating. Use object grouping : Simplify or optimize complex objects with a large number of points, paths, or patterns to improve performance. Limit object complexity : Attach a single event listener to the canvas and utilize event delegation to handle events for multiple objects efficiently. Use event delegation for interactivity : Use this utility function to batch rendering calls when making multiple changes to the canvas. Optimize rendering performance with fabric.util.requestRenderAll() : Implement lazy loading techniques to load images only when needed, reducing initial load time. Optimize image loading with lazy loading : Properly remove objects from the canvas and dispose of unused canvases to free up memory and improve performance. Dispose of unused objects and canvases You can optimize Fabric.js' performance and enhance your applications' user experience by applying these techniques.

FABRIC

fabricdata.com

-- employees

Since n.d.

COMPANY RANKING

FABRIC

EVERGREEN INDEX #4378

Representing this company? Click here to claim and customize this page!

Fabric WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!

FABRIC

fabricdata.com

-- employees

Since n.d.

COMPANY RANKING

FABRIC

EVERGREEN INDEX #4378

RELATED COMPANIESRANK

STORIES ABOUT FABRIC

Representing this company? Click here to claim and customize this page!

Fabric WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!